Как собрать массив (ы) непрерывных точек для контурной линии, используя Conrec - PullRequest
0 голосов
/ 31 марта 2011

У меня есть кошмар Conrec.Я пытаюсь реализовать контурные линии в ActionScript с помощью Conrec.Я посмотрел на реализацию java и javascript и все еще застрял.Они находятся здесь: http://paulbourke.net/papers/conrec/

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) - цикл (это вообще возможно?!).

Надеюсь, это имеет смысл,Я не уверен, есть ли технический термин для того, что я хочу сделать, помимо «конкатенации».Я также надеюсь, что кто-то там сделал это с Конреком и может дать мне несколько советов.

Тем временем, я собираюсь продолжать с этим мириться и посмотреть, смогу ли я придумать что-то, но яне уверен в своих силах.Я действительно был бы благодарен за какой-нибудь опытный или профессиональный совет.

PS: Если вы знаете другой способ рисовать контурные линии из данных сетки, я открыт для альтернатив.Но я должен быть в состоянии реализовать это в Actionscript.

Ответы [ 3 ]

0 голосов
/ 06 апреля 2011

Я просто портировал ConRec на Actionscript3 и, кажется, работает нормально, я не проверил его полностью, но он рисует мои контуры так, как я ожидаю. Попробуйте, если хотите, мне интересно, правильный ли это порт. это здесь:

http://www.jvanderspek.com/DEV/ConRec/ConRec.as

0 голосов
/ 10 мая 2011

Хорошо, так что может быть гораздо лучшая альтернатива для Flash.Я только что нашел эту ссылку, и она выглядит впечатляюще.Если это работает, это устраняет исходную проблему ...

изолирующий пакет для ActionScript 3

0 голосов
/ 01 апреля 2011

Хорошо, вот моя первая попытка получить то, что мне нужно сделать.Я не очень доволен результатом, но он , кажется, работает.

package {
  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" : ""));
    }
  }
}

Это даст следующие результаты:

A1, G1, F1, E1, D1, C1, B1, A1

G2, A2, B2, C2, D2, E2, F2, G2

G3, A3, B3, C3, D3, E3, F3, G3

G4, A4, B4, C4, D4, E4, F4, G4

Я все равно буду очень признателен за любые советы / отзывы, которые я смогу получить. никто не использует Conrec?!

Редактировать: woops!У меня была ошибка с оригинальным соединением ()!извиняюсь!исправлено

...