/**
* 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;
}
}