Actionscript 如何使用Conrec为等高线装配连续点阵列

我做了个恶梦。我正在尝试使用Conrec在ActionScript中实现轮廓线。我已经研究了java和javascript的实现，但仍然被卡住了。在这里可以找到：

Conrec将获取网格数据并装配连续的等高线。问题是，它不一定以连续的方式画出这些线。例如，它将绘制A->B，然后是C->B，然后是C->D，而不是A、B、C、D等

javascript实现似乎正在考虑这一点，并将指令序列化为一个绘图点数组。这也是我最终想要完成的。也就是说，它从核心Conrec逻辑（例如：A->B，C->B，C->D等）获取指令，并将其组织成A、B、C、D系列。我认为它还将以多维数组的形式返回序列，以容纳虚线（例如：[[a，B，C，D]，[E，F，G]]）。这最后一个功能是我在Actionscript中需要做的

这最后一部分是我被困的地方。暂时忽略Conrec（我已经放弃寻找Actionscript实现），如何将这些指令组织成一个序列点集合？当Conrec给我“从X->Y绘制点”时，我如何首先检查X或Y是否已经在序列中，并将X或Y（以不在序列中的为准）附加到序列中？如果两个都不在系列中，则以X，Y作为起始集开始新系列。然后对照所有现有系列和连接系列检查后续说明（如果它们现在在同一点上启动和停止）？此外，我需要能够允许一个系列自行关闭（例如：a，B，C，a）--一个循环（这可能吗？！）

我希望这是有道理的。我不确定除了“串联”之外，是否还有一个技术术语来描述我想做的事情。我也希望有人在Conrec做过这件事，能给我一些建议

与此同时，我将继续努力，看看我是否能想出一些办法，但我对自己的能力没有信心。我真的很感谢一些老兵或专业人士的建议

附言：

---

如果您知道从网格数据绘制等高线的另一种方法，我愿意接受其他方法。但我必须能够在Actionscript中实现它。

好的，这是我第一次尝试完成我需要的任务。我对结果不太满意，但似乎效果不错

包{
导入flash.display.Sprite；
公共类lineSeriesPointConcat扩展了Sprite{
公共功能lineSeriesPointConcat（）{
init（）；
}
//方向[X->Y]
//情况1：两者都是逆时针方向，结果是逆时针方向
私有变量case1:数组=[
[“G1”，“F1”]，
[“F1”、“E1”]，
[“D1”、“C1”]，
[“C1”、“B1”]，
[“B1”、“A1”]，
[“E1”，“D1”]，//链接
[“G1”，“A1”]//循环
];
//案例2：顺时针，逆时针，结果是顺时针
私有变量case2:数组=[
[“E2”，“F2”]，
[“F2”，“G2”]，
[“D2”、“C2”]，
[“C2”，“B2”]，
[“B2”，“A2”]，
[“E2”，“D2”]，//链接
[“G2”，“A2”]//循环
];
//案例3：均为顺时针，结果为顺时针
私有变量case3:数组=[
[“E3”、“F3”]，
[“F3”、“G3”]，
[“A3”、“B3”]，
[“B3”、“C3”]，
[“C3”、“D3”]，
[“E3”，“D3”]，//链接
[“G3”，“A3”]//循环
];
//案例4：逆时针，顺时针，结果为顺时针
私有变量case4:数组=[
[“G4”、“F4”]，
[“F4”、“E4”]，
[“A4”、“B4”]，
[“B4”、“C4”]，
[“C4”、“D4”]，
[“E4”，“D4”]，//链接
[“G4”，“A4”]//循环
];
私有变量collectedSeries:Array=[]；
私有函数init（）：void{
变量方向：数组=case1.concat（case2.concat（case3.concat（case4））；
对于每个（变量方向：方向中的数组）{
连接（方向[0]，方向[1]）；
}
跟踪（“最终系列：\n\t”+collectedSeries.join（“\n\t”）；
}
私有函数连接（from:String，to:String）：void{
var系列：数组；
var seriesStart:String；
var系列send:String；
var seriesIndex:int；
var n:int=collectedSeries.length；
变量i:int；
对于（i=0；ipackage {
  import flash.display.Sprite;

  public class lineSeriesPointConcat extends Sprite {
    public function lineSeriesPointConcat() {
      init();
    }
    //directions [X -> Y]
    //case 1: both counterclockwise, result is counterclockwise
    private var case1:Array = [
      ["G1", "F1"], 
      ["F1", "E1"], 

      ["D1", "C1"],
      ["C1", "B1"],
      ["B1", "A1"], 

      ["E1", "D1"], //link
      ["G1", "A1"] //loop
    ];

    //case 2: clockwise, counterclockwise, result is clockwise
    private var case2:Array = [
      ["E2", "F2"], 
      ["F2", "G2"], 

      ["D2", "C2"], 
      ["C2", "B2"], 
      ["B2", "A2"], 

      ["E2", "D2"], //link
      ["G2", "A2"] //loop
    ];

    //case 3: both clockwise, result is clockwise
    private var case3:Array = [
      ["E3", "F3"], 
      ["F3", "G3"], 

      ["A3", "B3"], 
      ["B3", "C3"], 
      ["C3", "D3"], 

      ["E3", "D3"], //link
      ["G3", "A3"] //loop
    ];

    //case 4: counterclockwise, clockwise, result is clockwise
    private var case4:Array = [
      ["G4", "F4"], 
      ["F4", "E4"], 

      ["A4", "B4"], 
      ["B4", "C4"], 
      ["C4", "D4"], 

      ["E4", "D4"], //link
      ["G4", "A4"] //loop
    ];


    private var collectedSeries:Array = [];

    private function init():void {
      var directions:Array = case1.concat(case2.concat(case3.concat(case4)));
      for each (var direction:Array in directions) {
        connect(direction[0], direction[1]);
      }
      trace ("final series:\n\t" + collectedSeries.join("\n\t"));
    }

    private function connect(from:String, to:String):void {
      var series:Array;
      var seriesStart:String;
      var seriesEnd:String;
      var seriesIndex:int;
      var n:int = collectedSeries.length;
      var i:int;
      for (i = 0; i < n; i++) {
        series = collectedSeries[i];
        seriesStart = series[0];
        seriesEnd = series[series.length - 1];

        if (seriesStart == to) {
          seriesStart = from;
          series.unshift(from);
          break;
        } else if (seriesStart == from) {
          seriesStart = to;
          series.unshift(to);
          break;
        } else if (seriesEnd == to) {
          seriesEnd = from;
          series.push(from);
          break;
        } else if (seriesEnd == from) {
          seriesEnd = to;
          series.push(to);
          break;
        }
      }

      if (i == n) {
        //this is a new series segment
        series = [from, to];
        seriesStart = from;
        seriesEnd = to;
        collectedSeries.push(series);
      }

      for (var j:int = 0; j < n; j++) {
        var compareSeries:Array = collectedSeries[j];
        if (compareSeries == series) {
          //don't compare the series to itself.
          continue;
        }
        var compSeriesStart:String = compareSeries[0];
        var compSeriesEnd:String = compareSeries[compareSeries.length - 1];
        if (compSeriesStart == compSeriesEnd) { 
          //this series loops on itself, it will not concatenate further
          continue;
        }
        if (compSeriesStart == seriesEnd) {
          trace ("case 1");
          series = series.concat(compareSeries.slice(1));
        } else if (compSeriesStart == seriesStart) {
          trace ("case 2");
          series = compareSeries.reverse().concat(series.slice(1));
        } else if (compSeriesEnd == seriesStart) {
          trace ("case 3");
          series = compareSeries.concat(series.slice(1));
        } else if (compSeriesEnd == seriesEnd) {
          trace ("case 4");
          series = compareSeries.concat(series.reverse().slice(1));
        } else {
          //no linkage between these two series
          continue;
        }
        collectedSeries[i] = series; //replace one of the two segements
        collectedSeries.splice(j, 1); //splice out the other
        break;
      }
      trace ("series: " + series + (i == n ? " new" : ""));
    }
  }
}