Package jmt.engine.jaba

Source Code of jmt.engine.jaba.SectorEngine

/**   
* Copyright (C) 2006, Laboratorio di Valutazione delle Prestazioni - Politecnico di Milano

* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.

* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/

package jmt.engine.jaba;

import java.util.Vector;

import jmt.engine.jaba.Hull.ConvexHullException;
import jmt.engine.jaba.Hull.Vertex;

/**
* Created by IntelliJ IDEA. User: Andrea Zanzottera Date: 1-ago-2005 Time:
* 10.30.07
*/
public class SectorEngine {

  // Istanzio la classe ViewResults per stampare a video i risultati
  // ViewResults vres = new ViewResults();
  // Inizializzo il vettore che sarà poi passato dalla funzione faces3d
  Vector<newFace> faces = new Vector<newFace>();
  // Inizializzo il vettore dei lati da unire per il calcolo
  Vector<Object> lati = new Vector<Object>();
  // Inizializzo il vettore contenente i settori dove saturano 3 stazioni
  // contemporaneamente
  Vector<Object> triangles = new Vector<Object>();
  // Inizializzo il vettore contenente i settori dove saturano 2 stazioni
  // contemporaneamente
  Vector<Object> sett2staz = new Vector<Object>();
  // Inizializzo il vettore contenente i settori dove satura 1 stazione
  Vector<Object> sett1staz = new Vector<Object>();
  // Duplico il vettore dei vertici per fare dei controlli finali
  Vector<Vertex> original3D = new Vector<Vertex>();

  /**
   * Passando un vettore di newPoint contenente le D di due classi il metodo
   * restituisce un Vector di Sector2D con le informazioni sul mix di
   * popolazione e le stazioni che saturano per quel mix.
   *
   * @param vertices2D
   * @return un Vector di Sector2D
   */
  public Vector<Sector2D> Calc2D(Vector<newPoint> vertices2D) {
    Vector<newPoint> original2D = new Vector<newPoint>(vertices2D);
    Util2d util = new Util2d();

    // Aggiungo le proiezioni
    vertices2D = util.LExplode2D(vertices2D);

    // Elimino i punti ridondanti (ALTRIMENTI GRAHAMSCAN CRASHA!!!)
    Vector<newPoint> verticesnew = new Vector<newPoint>();
    for (int i = 0; i < vertices2D.size(); i++) {
      if (util.VPresent(vertices2D.get(i), verticesnew) == false) {
        verticesnew.addElement(vertices2D.get(i));
      }
    }
    vertices2D = verticesnew;

    // Elimino i punti dominati
    vertices2D = util.DomRemove2D(vertices2D);

    // Aggiungo l'origine per rendere effettivamente convesso il poligono
    // Serve perchè il Graham Scan è stato pensato per ogni caso
    vertices2D.addElement(new newPoint(0, 0));

    // Lancio la funzione doGraham che chiede come parametro un vettore di
    // newPoint e restituisce il vettore lines di newPoint
    grahamScan gra = new grahamScan();
    vertices2D = gra.doGraham(vertices2D);

    // todo controllare meglio le proiezioni: caso (10,4) - (10,0)
    // bisogna fare in modo che un punto venga cmq scartato se è collineare
    // Elimino le proiezioni v1.5
    Vector<newPoint> verticesnp = new Vector<newPoint>();
    for (int i = 0; i < vertices2D.size(); i++) {
      if (util.VPresent(vertices2D.get(i), original2D)) {
        verticesnp.addElement(vertices2D.get(i));

      }
    }
    // Elimino le proiezioni nel caso siano collineari ad altri punti
    // Ad esempio (10,4) - (10,0) oppure (0,5) - (5,5)
    if (verticesnp.size() > 1) {
      verticesnp = util.RemoveCollinear(verticesnp);
    }

    // Faccio il mapping sui punti rimasti
    Beta2D b2d = new Beta2D();
    Vector<Sector2D> sector = new Vector<Sector2D>(); // è il vettore con le
                              // Beta
    sector = b2d.BetaVector(verticesnp);

    // System.out.println(sector.size());

    /*
     * //Aggiungo i punti collineari "diagonali" inserendoli nel giusto
     * posto if (verticesnp.size()>1 && original2D.size()>1) { for (int
     * i=0;i<(verticesnp.size()-1);i++) { for (int
     * j=0;j<original2D.size();j++) { // un vertice è buono quando non è già
     * incluso, // è collineare ai 2 del settore // la sua x è maggiore del
     * primo v del settore // la sua x è minore del secondo v del settore
     *
     * if (verticesnp.contains(original2D.get(j))==false &&
     * util.Collinear((newPoint
     * )verticesnp.get(i),(newPoint)verticesnp.get(i+
     * 1),(newPoint)original2D.get(j)) &&
     * (((newPoint)verticesnp.get(i)).getX
     * ()<((newPoint)original2D.get(j)).getX()) &&
     * (((newPoint)verticesnp.get
     * (i+1)).getX()>((newPoint)original2D.get(j)).getX()) ) {
     * verticesnp.insertElementAt(original2D.get(j),i); //i--; } } } }
     */

    Vector<Sector2D> res = new Vector<Sector2D>();

    if (verticesnp.size() > 1) {
      // Associo ai settori le stazioni
      res = b2d.StatAss(sector);

      /*
       * for (int i=0;i<sector.size();i++)
       * System.out.println(sector.get(i));
       */

      // Aggiunta dei punti collineari
      for (int i = 0; i < res.size(); i++) // per tutti i settori
      {
        for (int j = 0; j < original2D.size(); j++) // per tutti i punti
                              // originali
        {
          // Collineare Orizzontale Iniziale
          if (i == 0 && (res.get(i).getP1()).getX() != 0) {
            res.get(i).addCollinearFirst(res.get(i),
                original2D.get(j));
          }

          // Collieari Diagonali
          res.get(i).addCollinear(res.get(i), original2D.get(j));

          // Collineare sul lato verticale
          if (i == res.size() - 1 && (res.get(i).getP1()).getY() != 0) {
            res.get(i).addCollinearLast(res.get(i),
                original2D.get(j));
          }

        }
      }
    } else
    // Se satura soltanto una stazione
    {
      res.addElement(new Sector2D(1, 0, 0, 1, verticesnp.get(0)));
    }

    return res;
  }

  public Vector<Object> Calc2D(Vector<newPoint> vertices2D,
      String[] stationNames, String[] classNames) {
    Vector<newPoint> original2D = new Vector<newPoint>(vertices2D);
    Util2d util = new Util2d();

    // creo il vettore con le stazioni, serve per associare nome a
    // coordinate
    Vector<Station2D> stations = new Vector<Station2D>();
    for (int i = 0; i < vertices2D.size(); i++) {
      Station2D stat = new Station2D(vertices2D.get(i), stationNames[i]);
      stations.addElement(stat);
    }
    // Aggiungo le proiezioni
    vertices2D = util.LExplode2D(vertices2D);

    // Elimino i punti ridondanti (ALTRIMENTI GRAHAMSCAN CRASHA!!!)
    Vector<newPoint> verticesnew = new Vector<newPoint>();
    for (int i = 0; i < vertices2D.size(); i++) {
      if (util.VPresent(vertices2D.get(i), verticesnew) == false) {
        verticesnew.addElement(vertices2D.get(i));
      }
    }
    vertices2D = verticesnew;

    // Elimino i punti dominati
    vertices2D = util.DomRemove2D(vertices2D);

    // Aggiungo l'origine per rendere effettivamente convesso il poligono
    // Serve perchè il Graham Scan è stato pensato per ogni caso
    vertices2D.addElement(new newPoint(0, 0));

    // Lancio la funzione doGraham che chiede come parametro un vettore di
    // newPoint e restituisce il vettore lines di newPoint

    grahamScan gra = new grahamScan();
    vertices2D = gra.doGraham(vertices2D);

    // todo controllare è il nuovo (e non funziona!)
    /*
     * newGraham gra = new newGraham();
     * vertices2D=gra.GrahamScan(vertices2D);
     */

    // todo controllare meglio le proiezioni: caso (10,4) - (10,0)
    // bisogna fare in modo che un punto venga cmq scartato se è collineare
    // Elimino le proiezioni v1.5
    Vector<newPoint> verticesnp = new Vector<newPoint>();
    for (int i = 0; i < vertices2D.size(); i++) {
      if (util.VPresent(vertices2D.get(i), original2D)) {
        verticesnp.addElement(vertices2D.get(i));

      }
    }
    // Elimino le proiezioni nel caso siano collineari ad altri punti
    // Ad esempio (10,4) - (10,0) oppure (0,5) - (5,5)
    if (verticesnp.size() > 1) {
      verticesnp = util.RemoveCollinear(verticesnp);
    }

    // Faccio il mapping sui punti rimasti
    Beta2D b2d = new Beta2D();
    Vector<Sector2D> sector = new Vector<Sector2D>(); // è il vettore con le
                              // Beta
    sector = b2d.BetaVector(verticesnp);

    // System.out.println(sector.size());

    /*
     * //Aggiungo i punti collineari "diagonali" inserendoli nel giusto
     * posto if (verticesnp.size()>1 && original2D.size()>1) { for (int
     * i=0;i<(verticesnp.size()-1);i++) { for (int
     * j=0;j<original2D.size();j++) { // un vertice è buono quando non è già
     * incluso, // è collineare ai 2 del settore // la sua x è maggiore del
     * primo v del settore // la sua x è minore del secondo v del settore
     *
     * if (verticesnp.contains(original2D.get(j))==false &&
     * util.Collinear((newPoint
     * )verticesnp.get(i),(newPoint)verticesnp.get(i+
     * 1),(newPoint)original2D.get(j)) &&
     * (((newPoint)verticesnp.get(i)).getX
     * ()<((newPoint)original2D.get(j)).getX()) &&
     * (((newPoint)verticesnp.get
     * (i+1)).getX()>((newPoint)original2D.get(j)).getX()) ) {
     * verticesnp.insertElementAt(original2D.get(j),i); //i--; } } } }
     */

    Vector<Sector2D> res = new Vector<Sector2D>();

    if (verticesnp.size() > 1) {
      // Associo ai settori le stazioni
      res = b2d.StatAss(sector);

      /*
       * for (int i=0;i<sector.size();i++)
       * System.out.println(sector.get(i));
       */

      // Aggiunta dei punti collineari
      for (int i = 0; i < res.size(); i++) // per tutti i settori
      {
        for (int j = 0; j < original2D.size(); j++) // per tutti i punti
                              // originali
        {
          // Collineare Orizzontale Iniziale
          if (i == 0 && (res.get(i).getP1()).getX() != 0) {
            res.get(i).addCollinearFirst(res.get(i),
                original2D.get(j));
          }

          // Collieari Diagonali
          res.get(i).addCollinear(res.get(i), original2D.get(j));

          // Collineare sul lato verticale
          if (i == res.size() - 1 && (res.get(i).getP1()).getY() != 0) {
            res.get(i).addCollinearLast(res.get(i),
                original2D.get(j));
          }

        }
      }
    } else
    // Se satura soltanto una stazione
    {
      res.addElement(new Sector2D(1, 0, 0, 1, verticesnp.get(0)));
    }

    Vector<Object> finalres = new Vector<Object>();

    for (int i = 0; i < res.size(); i++) {
      FinalSect2D fs = new FinalSect2D(res.get(i), stations, classNames);
      finalres.addElement(fs);
    }

    return finalres;
  }
 
  public DPoint calcEquiUtilizationPoint(Vector<newPoint> vertices2D) {
    // NEW Spicuglia
    // If there are two station we calculate the equiutilization point
    if (vertices2D.size() == 2) {
      double L11, L12, L21, L22;
      double b1;
      double b2;
 
      L11 =  vertices2D.get(0).x;
      L12 =  vertices2D.get(0).y;
      L21 =  vertices2D.get(1).x;
      L22 = vertices2D.get(1).y;
      b1 = Math.log(L22/L12) / Math.log((L11*L22)/(L12*L21));
      b2 = 1 - b1;
      return new DPoint(b1, b2);
    }
    return null;
    // END Spicuglia
  }

  /**
   * CASO 3 CLASSI
   *
   */
  public Vector<Object> Calc3D(Vector<Vertex> vertices)
      throws ConvexHullException {
    Vector<Object> out = new Vector<Object>();
    // I vertici sono contentuti in vertices(si modifica coi calcoli) e
    // original
    // Le facce del CHull sono in faces
    // I settori triangolari in cui saturano 3 stazioni sono in triangles
    // I settori quadrangolari in cui saturano 2 stazioni sono in sett2staz

    original3D = vertices;

    Vector<newPoint> vertices2Dxy = new Vector<newPoint>();
    Vector<newPoint> vertices2Dxz = new Vector<newPoint>();
    Vector<newPoint> vertices2Dyz = new Vector<newPoint>();

    Faces3D faces3d = new Faces3D();

    // Istanzio la classe Beta3D
    Beta3D b3d = new Beta3D();

    // Istanzio la classe Segment3D
    Segment3D seg = new Segment3D();

    // Inizializzo il nome del file pdf che sarà creato
    String name = "noname";

    // ------------------------------------- START
    // ----------------------------------------------------//

    // Se c'è una sola stazione oppure una sola è dominante finisce qui
    OneDominator od = new OneDominator();
    od.setVertices(vertices);
    if (od.IsOneDominator()) {
      Vertex dom = od.getDominator();
      // System.out.println(dom);
      sett1staz = b3d.OneDominator(od.getDominator());

      out.addElement(faces);
      out.addElement(original3D);
      out.addElement(triangles);
      out.addElement(sett2staz);
      out.addElement(sett1staz);
      out.addElement(name);

      return out;
    }

    if (vertices.size() == 1) {
      sett1staz = b3d.OneDominator(vertices.get(0));

      out.addElement(faces);
      out.addElement(original3D);
      out.addElement(triangles);
      out.addElement(sett2staz);
      out.addElement(sett1staz);
      out.addElement(name);

      return out;
    }

    // ------------------------------------- FASE 3D
    // -----------------------------------------------//

    // Controllo che ci siano almeno 3 stazioni prima di fare il CHull
    if (vertices.size() > 2) {

      // Esplodo il vettore dei vertici creando anche le proiezioni
      vertices = faces3d.LExplode3D(vertices);

      // Chiamo il metodo Hull3D della classe faces3d che mi restituisce
      // le facce del poligono già contrassegnando quelle complanari
      faces = faces3d.Hull3D(vertices);

      // Controllo che ci sia almeno una faccia
      if (faces.size() > 0) {
        // Tolgo le facce contenenti proiezioni
        faces = faces3d.RemoveP(faces, original3D);

        // Associazione delle Beta alle facce triangolari
        triangles = b3d.BetaTriangles(faces);

        // Genero i lati da unire
        lati = seg.CreateLt(triangles);

        // Join dei triangoli
        if (triangles.size() > 1) {
          sett2staz = b3d.JoinTriangles(triangles);
        }

        // Tolgo i lati usati dal join e aggiungo quelli creati
        lati = seg.FixLtFromJoin(sett2staz, lati);

        // ------------------------------------- FASE 2D
        // ----------------------------------------------------//

      }// if (faces.size()>0)
    }// if (vertices.size()>2)
      // else System.out.println("non ci sono abbastanza vertici");

    vertices2Dxy = faces3d.VertexRemoveZ(original3D);
    vertices2Dxz = faces3d.VertexRemoveY(original3D);
    vertices2Dyz = faces3d.VertexRemoveX(original3D);

    Vector<Sector2D> resxy = new Vector<Sector2D>();
    Vector<Sector2D> resxz = new Vector<Sector2D>();
    Vector<Sector2D> resyz = new Vector<Sector2D>();

    SectorEngine calcolo2d = new SectorEngine();

    // Genero il lato del triangolo con beta3=0
    resxy = calcolo2d.Calc2D(vertices2Dxy);

    // Genero il lato del triangolo con beta2=0
    resxz = calcolo2d.Calc2D(vertices2Dxz);

    // Genero il lato del triangolo con beta1=0
    resyz = calcolo2d.Calc2D(vertices2Dyz);

    // Differenzio la procedura nel caso ci sia un settore con 3 stazioni
    // saturanti contemp.
    // dal quale partire per unire i segmenti a lato del triangolo o meno.

    // LATI XY
    Vector<Vector<Object>> newresxy = new Vector<Vector<Object>>();
    Vector<Object> latixy = new Vector<Object>();
    latixy = seg.FixLtFrom2Dxy(resxy);

    // LATI XZ
    Vector<Vector<Object>> newresxz = new Vector<Vector<Object>>();
    Vector<Object> latixz = new Vector<Object>();
    latixz = seg.FixLtFrom2Dxz(resxz);

    // LATI YZ
    Vector<Vector<Object>> newresyz = new Vector<Vector<Object>>();
    Vector<Object> latiyz = new Vector<Object>();
    latiyz = seg.FixLtFrom2Dyz(resyz);

    if (faces.size() > 0) {
      newresxy = b3d.Join2Statxy(latixy, lati, sett2staz);
      sett2staz = newresxy.get(0);
      lati = newresxy.get(1);
      latixy = newresxy.get(2);

      newresxz = b3d.Join2Statxz(latixz, lati, sett2staz);
      sett2staz = newresxz.get(0);
      lati = newresxz.get(1);
      latixz = newresxz.get(2);

      newresyz = b3d.Join2Statyz(latiyz, lati, sett2staz);
      sett2staz = newresyz.get(0);
      lati = newresyz.get(1);
      latiyz = newresyz.get(2);

      /*
       * // Stampa dei settori in cui saturano 2 stazioni
       * System.out.println
       * ("Numero di settori in cui saturano 2 stazioni contemp.: "
       * +sett2staz.size()); vres.ViewRes3D2Stat(sett2staz,original3D);
       */

      // ------------------------------ 1 STAZIONE
      // --------------------------------------------------------
      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

      // ------------------------------ FACCE COMPLANARI
      // -------------------------------------------------

      // Controllo se ci sono facce complanari
      if (faces3d.ExistsComplanar(faces)) {
        // System.out.println("ESISTONO FACCE COMPLANARI");
        triangles = b3d.JoinComplanars(triangles);
        // System.out.println(triangles.size());
        sett2staz = b3d.DeleteFake(sett2staz);
      }
      // todo creare metodo che aggiunge stazioni complanari ulteriori
      // (ossia quelle che pur essendo complanari vengono scartate dal
      // cHull)

    }// if faces.size()>0

    // ------------------------------ CASO IN CUI NON CI SONO FACCE
    // ------------------------------------

    else // (if faces.size==0)
    {
      Vector<Vector<Object>> resN31 = new Vector<Vector<Object>>();
      // System.out.println("Non ci sono facce");

      // Ricerca dei settori in cui saturano 2 stazioni
      resN31 = b3d.Join2StazN3(latixy, latixz, latiyz, sett1staz,
          sett2staz);

      // System.out.println("resN31.size(): "+resN31.size());

      lati = resN31.get(0);
      latixy = resN31.get(1);
      latixz = resN31.get(2);
      latiyz = resN31.get(3);
      sett1staz = resN31.get(4);
      sett2staz = resN31.get(5);

      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);
      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

    }

    /*
     * //Generazione dei risultati out.addElement(faces);
     * out.addElement(original3D); out.addElement(triangles);
     * out.addElement(sett2staz); out.addElement(sett1staz);
     * out.addElement(name);
     */

    Mapping3D map = new Mapping3D();
    map.RemapAllSectors(triangles);
    map.RemapAllSectors(sett2staz);
    map.RemapAllSectors(sett1staz);

    Vector<Object> allres = new Vector<Object>();
    for (int i = 0; i < sett1staz.size(); i++) {
      allres.addElement(sett1staz.get(i));
    }
    for (int i = 0; i < sett2staz.size(); i++) {
      allres.addElement(sett2staz.get(i));
    }
    for (int i = 0; i < triangles.size(); i++) {
      allres.addElement(triangles.get(i));
    }

    return allres;
    // return out;
  }

  public Vector<Object> Calc3D(Vector<Vertex> vertices,
      String[] stationNames, String[] classNames)
      throws ConvexHullException {
    Vector<Object> out = new Vector<Object>();
    // I vertici sono contentuti in vertices(si modifica coi calcoli) e
    // original
    // Le facce del CHull sono in faces
    // I settori triangolari in cui saturano 3 stazioni sono in triangles
    // I settori quadrangolari in cui saturano 2 stazioni sono in sett2staz

    Vector<Station3D> stations = new Vector<Station3D>();

    // Creo un vettore con le stazioni associate ai loro nomi
    for (int i = 0; i < vertices.size(); i++) {
      stations.add(new Station3D(stationNames[i], vertices.get(i)));
    }

    original3D = vertices;

    Vector<newPoint> vertices2Dxy = new Vector<newPoint>();
    Vector<newPoint> vertices2Dxz = new Vector<newPoint>();
    Vector<newPoint> vertices2Dyz = new Vector<newPoint>();

    Faces3D faces3d = new Faces3D();

    // Istanzio la classe Beta3D
    Beta3D b3d = new Beta3D();

    // Istanzio la classe Segment3D
    Segment3D seg = new Segment3D();

    // Inizializzo il nome del file pdf che sarà creato
    String name = "noname";

    // ------------------------------------- START
    // ----------------------------------------------------//

    // Se c'è una sola stazione oppure una sola è dominante finisce qui
    OneDominator od = new OneDominator();
    od.setVertices(vertices);
    if (od.IsOneDominator()) {
      Vertex dom = od.getDominator();
      // System.out.println(dom);
      sett1staz = b3d.OneDominator(od.getDominator());

      // out.addElement(faces);
      out.addElement(original3D);
      // out.addElement(triangles);
      // out.addElement(sett2staz);
      out.addElement(sett1staz);
      // out.addElement(name);
      Mapping3D map = new Mapping3D();
      // map.RemapAllSectors(triangles);
      // map.RemapAllSectors(sett2staz);
      map.RemapAllSectors(sett1staz);

      Vector<Object> allres = new Vector<Object>();
      for (int i = 0; i < sett1staz.size(); i++) {
        allres.addElement(sett1staz.get(i));
      }/*
       * for (int i = 0; i<sett2staz.size();i++){
       * allres.addElement((Sector3D)sett2staz.get(i)); } for (int i = 0;
       * i<triangles.size();i++){
       * allres.addElement((Sector3D)triangles.get(i)); }
       */

      // System.out.println("allres.size() = "+allres.size());
      for (int i = 0; i < allres.size(); i++) {
        ((Sector3D) allres.get(i)).givename(stations);
        ((Sector3D) allres.get(i)).setClassNames(classNames);
      }

      return allres;
      // todo il nome e tutto il resto!
      // return out;
    }

    if (vertices.size() == 1) {
      sett1staz = b3d.OneDominator(vertices.get(0));

      out.addElement(faces);
      out.addElement(original3D);
      out.addElement(triangles);
      out.addElement(sett2staz);
      out.addElement(sett1staz);
      out.addElement(name);

      return out;
    }

    // ------------------------------------- FASE 3D
    // -----------------------------------------------//

    // Controllo che ci siano almeno 3 stazioni prima di fare il CHull
    if (vertices.size() > 2) {

      // Esplodo il vettore dei vertici creando anche le proiezioni
      vertices = faces3d.LExplode3D(vertices);

      // Chiamo il metodo Hull3D della classe faces3d che mi restituisce
      // le facce del poligono già contrassegnando quelle complanari
      faces = faces3d.Hull3D(vertices);

      // Controllo che ci sia almeno una faccia
      if (faces.size() > 0) {
        // Tolgo le facce contenenti proiezioni
        faces = faces3d.RemoveP(faces, original3D);

        // Associazione delle Beta alle facce triangolari
        triangles = b3d.BetaTriangles(faces);

        // Genero i lati da unire
        lati = seg.CreateLt(triangles);

        // Join dei triangoli
        if (triangles.size() > 1) {
          sett2staz = b3d.JoinTriangles(triangles);
        }

        // Tolgo i lati usati dal join e aggiungo quelli creati
        lati = seg.FixLtFromJoin(sett2staz, lati);

        // ------------------------------------- FASE 2D
        // ----------------------------------------------------//

      }// if (faces.size()>0)
    }// if (vertices.size()>2)
      // else System.out.println("non ci sono abbastanza vertici");

    vertices2Dxy = faces3d.VertexRemoveZ(original3D);
    vertices2Dxz = faces3d.VertexRemoveY(original3D);
    vertices2Dyz = faces3d.VertexRemoveX(original3D);

    Vector<Sector2D> resxy = new Vector<Sector2D>();
    Vector<Sector2D> resxz = new Vector<Sector2D>();
    Vector<Sector2D> resyz = new Vector<Sector2D>();

    SectorEngine calcolo2d = new SectorEngine();

    // Genero il lato del triangolo con beta3=0
    resxy = calcolo2d.Calc2D(vertices2Dxy);

    // Genero il lato del triangolo con beta2=0
    resxz = calcolo2d.Calc2D(vertices2Dxz);

    // Genero il lato del triangolo con beta1=0
    resyz = calcolo2d.Calc2D(vertices2Dyz);

    // Differenzio la procedura nel caso ci sia un settore con 3 stazioni
    // saturanti contemp.
    // dal quale partire per unire i segmenti a lato del triangolo o meno.

    // LATI XY
    Vector<Vector<Object>> newresxy = new Vector<Vector<Object>>();
    Vector<Object> latixy = new Vector<Object>();
    latixy = seg.FixLtFrom2Dxy(resxy);

    // LATI XZ
    Vector<Vector<Object>> newresxz = new Vector<Vector<Object>>();
    Vector<Object> latixz = new Vector<Object>();
    latixz = seg.FixLtFrom2Dxz(resxz);

    // LATI YZ
    Vector<Vector<Object>> newresyz = new Vector<Vector<Object>>();
    Vector<Object> latiyz = new Vector<Object>();
    latiyz = seg.FixLtFrom2Dyz(resyz);

    if (faces.size() > 0) {
      newresxy = b3d.Join2Statxy(latixy, lati, sett2staz);
      sett2staz = newresxy.get(0);
      lati = newresxy.get(1);
      latixy = newresxy.get(2);

      newresxz = b3d.Join2Statxz(latixz, lati, sett2staz);
      sett2staz = newresxz.get(0);
      lati = newresxz.get(1);
      latixz = newresxz.get(2);

      newresyz = b3d.Join2Statyz(latiyz, lati, sett2staz);
      sett2staz = newresyz.get(0);
      lati = newresyz.get(1);
      latiyz = newresyz.get(2);

      /*
       * // Stampa dei settori in cui saturano 2 stazioni
       * System.out.println
       * ("Numero di settori in cui saturano 2 stazioni contemp.: "
       * +sett2staz.size()); vres.ViewRes3D2Stat(sett2staz,original3D);
       */

      // ------------------------------ 1 STAZIONE
      // --------------------------------------------------------
      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

      // ------------------------------ FACCE COMPLANARI
      // -------------------------------------------------

      // Controllo se ci sono facce complanari
      if (faces3d.ExistsComplanar(faces)) {
        // System.out.println("ESISTONO FACCE COMPLANARI");
        triangles = b3d.JoinComplanars(triangles);
        // System.out.println(triangles.size());
        sett2staz = b3d.DeleteFake(sett2staz);
      }
      // todo creare metodo che aggiunge stazioni complanari ulteriori
      // (ossia quelle che pur essendo complanari vengono scartate dal
      // cHull)

    }// if faces.size()>0

    // ------------------------------ CASO IN CUI NON CI SONO FACCE
    // ------------------------------------

    else // (if faces.size==0)
    {
      Vector<Vector<Object>> resN31 = new Vector<Vector<Object>>();
      // System.out.println("Non ci sono facce");

      // Ricerca dei settori in cui saturano 2 stazioni
      resN31 = b3d.Join2StazN3(latixy, latixz, latiyz, sett1staz,
          sett2staz);

      // System.out.println("resN31.size(): "+resN31.size());

      lati = resN31.get(0);
      latixy = resN31.get(1);
      latixz = resN31.get(2);
      latiyz = resN31.get(3);
      sett1staz = resN31.get(4);
      sett2staz = resN31.get(5);

      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);
      sett1staz = b3d.Join1Staz(latixy, latixz, latiyz, lati, sett1staz);

    }

    // ------------------------------ MAPPATURA NELLE 2 DIMENSIONI DELLO
    // SPAZIO BETA -------------------

    Mapping3D map = new Mapping3D();
    if (faces.size() > 0) {
      map.RemapAllSectors(triangles);
    }
    map.RemapAllSectors(sett2staz);
    map.RemapAllSectors(sett1staz);

    Vector<Object> allres = new Vector<Object>();
    for (int i = 0; i < sett1staz.size(); i++) {
      allres.addElement(sett1staz.get(i));
    }
    for (int i = 0; i < sett2staz.size(); i++) {
      allres.addElement(sett2staz.get(i));
    }
    if (faces.size() > 0) {
      for (int i = 0; i < triangles.size(); i++) {
        allres.addElement(triangles.get(i));
      }
    }

    // System.out.println("allres.size() = "+allres.size());
    for (int i = 0; i < allres.size(); i++) {
      ((Sector3D) allres.get(i)).givename(stations);
      ((Sector3D) allres.get(i)).setClassNames(classNames);
    }

    return allres;
    // return out;
  }

  // Metodi per avere i risultati
  public Vector<newFace> getFaces() {
    return faces;
  }

  public Vector<Object> gettriangles() {
    return triangles;
  }

  public Vector<Object> getsett1staz() {
    return sett1staz;
  }

  public Vector<Object> getsett2staz() {
    return sett2staz;
  }

}
TOP

Related Classes of jmt.engine.jaba.SectorEngine

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.