along/secondo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
dfd1e745480fabd88139d2804acb90d5b6dc055e
secondo/Algebras/Fuzzy/fuzzyobjects/composite/FLine.java

1955 lines
50 KiB
Java
Raw Normal View History

firs commit
2026-01-23 17:03:45 +08:00
//This file is part of SECONDO.
//Copyright (C) 2004, University in Hagen, Department of Computer Science,
//Database Systems for New Applications.
//SECONDO 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.
//SECONDO 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 SECONDO; if not, write to the Free Software
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
package fuzzyobjects.composite;
import fuzzyobjects.basic.*;
import fuzzyobjects.simple.*;
import java.util.Vector;
import sj.lang.ListExpr;
import java.io.*;
/**
* this class provides a implementation of fuzzy Lines
* in the X-triangulation
* @author Thomas Behr
*/
public class FLine implements CompositeObject{
/**
* the factor of scale
*/
protected double SF;
/** the fuzzy segments */
protected SortedObjects fSeg;
/** returns the SortedObjects of this Line */
SortedObjects getSortedObjects(){
return fSeg;
}
/** remove all conataing segments */
public void clear(){
fSeg.makeEmpty();
}
/** returns the number of containing fuzzy segments */
public int getSize(){
return fSeg.getSize();
}
/* retuns the fuzzy segment at position index,
if this object not exists null is returned
*/
public fSegment getSegmentAt(int index){
if(index<0 || index>=fSeg.getSize())
return null;
return (fSegment) fSeg.get(index);
}
/** the bounding box */
protected BoundingBox BB = new BoundingBox();
/** returns the bounding box of this line */
public BoundingBox getBoundingBox(){ return BB; }
/** overwrite the given Path by a new FLine by
* linear aprox.
*/
public boolean overwritePath(Path P, double Start, double End){
if(P==null | Start<0 | Start>1 | End<0 | End>1)
return false;
else{
boolean removePath = (Start+End==0);
double length = P.getLength();
double currentLength = 0;
int max = P.getNumberOfSegments();
double delta = End-Start;
double CLength;
BasicSegment C;
double M1,M2;
BasicPoint BP;
for(int i=0;i<max;i++){
C = P.getSegment(i);
BP = P.getPoint(i);
CLength = C.length();
if (removePath){
fSeg.delete(C);
}
else {
M1 = Start+delta*(currentLength/length);
M2 = Start+delta*((currentLength+CLength)/length);
if(BP.equals( (BasicPoint) C.getEP1()))
overwrite(new fSegment(C,M1,M2));
else
overwrite(new fSegment(C,M2,M1));
}
currentLength += CLength;
}
return true;
} // else
}
/** computes the bounding box of this line */
private void computeBoundingBox(){
if(fSeg.isEmpty())
BB.setBox(0,0,0,0);
else{
SimpleObject FS = fSeg.get(0);
int minX = FS.getMinX();
int minY = FS.getMinY();
int maxX = FS.getMaxX();
int maxY = FS.getMaxY();
int cX,cY;
for (int i=1;i<fSeg.getSize();i++){
FS = fSeg.get(i);
cX = FS.getMinX();
cY = FS.getMinY();
if(cX < minX)
minX = cX;
if(cY < minY)
minY = cY;
cX = FS.getMaxX();
cY = FS.getMaxY();
if(cX > maxX)
maxX = cX;
if(cY > maxY)
maxY = cY;
}
BB.setBox(minX,minY,maxX,maxY);
}
}
/**
* creates a new FLine
* with scale as factor of scale
*/
public FLine(double scale){
fSeg = new SortedObjects();
SF = scale;
}
/** set the new factor of scale */
public boolean setSF(double SF){
if(SF>0){
this.SF=SF;
return true;
}
else return false;
}
/**
* creates a new FLine
* with 1 as factor of scale
*/
public FLine() {
this(1.0);
}
/** get the factor of scale */
public double getSF(){ return SF; }
/**
* get the dimension of a line
* i.e. 1
*/
public int getDim(){ return 1; }
/**
* is this a valid line in the X-triangulation ?
* i.e. check whether SF greater then 0 and all
* containing fuzzy segments are valid
*/
public boolean isValid(){
return SF>0 & fSeg.allValid();
}
/**
* returns a readable String of this FLine
*/
public String toString(){
return "FLine (SF="+SF+")\n" + fSeg.toString();
}
/**
* adds a new fuzzy Segment to this Line
* if this FLine contains a segment whith same basic as fS
* the fS not added and the result ist false
*/
public boolean add(fSegment fS){
boolean first = fSeg.isEmpty();
boolean ok = fSeg.insert(fS.copy());
if(ok) { // update bounding box
if(!first){
int minX = BB.getMinX();
int minY = BB.getMinY();
int maxX = BB.getMaxX();
int maxY = BB.getMaxY();
if(minX>fS.getMinX())
minX = fS.getMinX();
if(minY>fS.getMinY())
minY = fS.getMinY();
if(maxX<fS.getMaxX())
maxX = fS.getMaxX();
if(maxY<fS.getMaxY())
maxY = fS.getMaxY();
BB.setBox(minX,minY,maxX,maxY);
}
else
BB.setBox(fS.getMinX(),fS.getMinY(),
fS.getMaxX(),fS.getMaxY());
}
return ok;
}
/**
* updated a fuzzy Segments in this fLine
* if not a segment whith same basic as fS in this
* FLine then the result is false
*/
public boolean update(fSegment fS){
return fSeg.update(fS.copy());
}
/**
* updated/added a fuzzy Segment of this FLine
* if this FLine contains a Segment wthis same basic as fS
* then this Segment was updates
* else fS is added to this FLine
*/
public void overwrite(fSegment fS){
boolean first = fSeg.isEmpty();
if (! fSeg.update(fS))
fSeg.insert(fS);
if(!first){
int minX = BB.getMinX();
int minY = BB.getMinY();
int maxX = BB.getMaxX();
int maxY = BB.getMaxY();
if(minX>fS.getMinX())
minX = fS.getMinX();
if(minY>fS.getMinY())
minY = fS.getMinY();
if(maxX<fS.getMaxX())
maxX = fS.getMaxX();
if(maxY<fS.getMaxY())
maxY = fS.getMaxY();
BB.setBox(minX,minY,maxX,maxY);
}
else
BB.setBox(fS.getMinX(),fS.getMinY(),
fS.getMaxX(),fS.getMaxY());
}
/**
* creates a new fuzzy Segments from the Parameters and
* if this yield a valid fuzzy segment
* then invoked <A href="#overwrite(fSegment)">
* overwrite(fSegment) </A>
*/
public boolean overwrite(int x1,int y1,double Z1,
int x2,int y2,double Z2 ){
fSegment fS = new fSegment(x1,y1,Z1, x2,y2,Z2);
if (fS.isValid()){
overwrite(fS);
return true;
}
else return false;
}
/**
* deletes the fuzzy Segment from this FLine
* with basic BS
* returns false if this FLine not contains such fSegment
*/
public boolean delete(BasicSegment BS){
boolean ok = fSeg.delete(BS);
if(ok & ( BS.getMinX()==BB.getMinX() |
BS.getMaxX()==BB.getMaxX() |
BS.getMinY()==BB.getMinY() |
BS.getMaxY()==BB.getMaxY() ) )
computeBoundingBox();
return ok;
}
/**
* computes all membershipvalues on (x,y)
*/
public double[] ZRel(double x, double y) {
double[] result;
BasicSegment[] Segs = BasicSegment.getSegments(x,y);
if(Segs == null){
result = new double[1];
result[0]=0;
}
else{
Vector tmp = new Vector();
fSegment current;
Double Z;
for(int i=0;i<Segs.length;i++){
current = (fSegment) fSeg.search(Segs[i]);
if (current!=null){
Z = new Double(current.Zfkt(x,y));
if(!tmp.contains(Z))
tmp.add(Z);
}
else{
if(!tmp.contains(new Double(0)))
tmp.add(new Double(0));
}
}
if(tmp.size()==0){
result = new double[1];
result[0]=0;
}
else{
result=new double[tmp.size()];
for(int i=0;i<tmp.size();i++)
result[i] = ((Double)tmp.get(i)).doubleValue();
}
}
return result;
} // ZRel
/** computes all membershipvalues on BP */
public double[] ZRel(BasicPoint BP){
Vector tmp = new Vector();
BasicPoint[] Neightboors = BP.getNeightboors();
for(int i=0;i<Neightboors.length;i++){
fSegment fS= (fSegment) fSeg.search(
new BasicSegment(
BP,Neightboors[i]));
if(fS!=null)
tmp.add(new Double( fS.Zfkt(BP)));
} // for all Neighboors
double[] result = new double[tmp.size()];
for(int j=0;j<tmp.size();j++)
result[j] = ( (Double) tmp.get(j)).doubleValue();
return result;
}
/** computes the maximal membershipvalue on BP */
public double maxZfkt(BasicPoint BP){
double[] cand = ZRel(BP);
double result = 0;
for(int i=0;i<cand.length;i++)
if(cand[i]>result)
result=cand[i];
return result;
}
/** computes the maximal membershipvalue on (x,y) */
public double maxZfkt(double x, double y){
double[] values = ZRel(x,y);
double result =0;
for(int i=0;i<values.length;i++)
if (values[i]>result) result = values[i];
return result;
}
/** computes the minimal membershipvalue on (x,y) */
public double minZfkt(double x, double y){
double[] values = ZRel(x,y);
double result =1;
for(int i=0;i<values.length;i++)
if (values[i]<result) result = values[i];
return result;
}
/** computes the middle membershipvalue on (x,y) */
public double midZfkt(double x, double y){
double[] values = ZRel(x,y);
double result =0;
for(int i=0;i<values.length;i++)
result += values[i];
result = result / values.length;
return result;
}
/** computes the membershipvalue on BP by given basic element */
public double Zfkt(BasicPoint BP, BasicSegment BS){
fSegment Fs = (fSegment) fSeg.search(BS);
double result = 0;
if(Fs!=null) {
result = Fs.Zfkt(BP);
}
return result;
}
/** computes the membershipvalue on (x,y) by given
* basic segment
*/
public double Zfkt(double x, double y, BasicSegment BS){
double result = 0;
if (BS.contains(x,y)){
fSegment Fs = (fSegment) fSeg.search(BS);
if(Fs!=null) {
result = Fs.Zfkt(x,y);
}
}
return result;
}
/** returns all containing basic segments of this FLine
* the Segments of result are sorted*/
public BasicSegment[] basics() {
BasicSegment[] result = new BasicSegment[fSeg.getSize()];
if(fSeg.isEmpty())
return result;
else{
for(int i=0;i<fSeg.getSize();i++)
result[i] = (BasicSegment) (
(fSegment)fSeg.get(i)).basic();
}
return result;
} // basics
/** returns the maximal membershipvalue in this FLine */
public double maxZ(){
double max = 0.0;
fSegment current;
for(int i=0;i<fSeg.getSize();i++){
current = (fSegment) fSeg.get(i);
if (max < Math.max(current.getZ1(),current.getZ2() ))
max = Math.max(current.getZ1(), current.getZ2());
}
return max;
} // maxZ
/** returns the minimal membershipvalue in this FLine */
public double minZ(){
double min = 1.0;
fSegment current;
for(int i=0;i<fSeg.getSize();i++){
current = (fSegment) fSeg.get(i);
if (min > Math.min(current.getZ1(),current.getZ2()) )
min = Math.min(current.getZ1(), current.getZ2());
}
return min;
} // minZ
/** returns a copy from this FLine */
public FLine copy(){
FLine C = new FLine(SF);
C.fSeg = fSeg.copy();
C.BB = BB.copy();
return C;
}
/** check whether this FLine contains elements */
public boolean isEmpty(){
return fSeg.isEmpty();
}
/** set the containing segments from this on the same
* as L2's one
*/
protected static void setfSeg(FLine L1, FLine L2){
L1.fSeg = L2.fSeg;
L1.BB = L2.BB;
}
/** computes the selfcuts of this Line */
public BasicPoint[] selfcuts(){
BasicSegment Current;
BasicPoint BP;
int n;
boolean found;
Vector tmp = new Vector(fSeg.getSize());
for(int i=0;i<fSeg.getSize();i++){
Current = (BasicSegment) ((fSegment)fSeg.get(i)).basic();
BP = Current.getEP1();
n = numberOfSegments(BP);
if(n>2){
found=false;
for(int j=0;j<tmp.size();j++)
if( ( (BasicPoint) tmp.get(j)).equals(BP))
found=true;
if(!found)
tmp.add(BP);
}
BP = Current.getEP2();
n = numberOfSegments(BP);
if(n>2){
found=false;
for(int j=0;j<tmp.size();j++)
if( ( (BasicPoint) tmp.get(j)).equals(BP))
found=true;
if(!found)
tmp.add(BP);
} // if
} // for all containing segments
BasicPoint[] result = new BasicPoint[tmp.size()];
for(int i=0;i<result.length;i++)
result[i] = (BasicPoint) tmp.get(i);
return result;
} // selfcuts
/*************************************************************
Operators
*************************************************************/
/** the union of 2 FLines */
public FLine union(FLine With){
return operator(With,UNION);
}
/** the scaled union of 2 FLines */
public FLine scaledUnion(FLine With){
FLine result = operator(With,SCALEDUNION);
result.norm();
return result;
}
/** the intersectionof 2 FLines */
public FLine intersection(FLine With){
return operator(With,INTERSECTION);
}
/** the scaled intersection of 2 FLines */
public FLine scaledIntersection(FLine With){
FLine result = operator(With,SCALEDINTERSECTION);
result.norm();
return result;
}
/** added With to this FLine */
public FLine add(FLine With){
return operator(With,ADD);
}
/** added scaled Witdh to this FLine */
public FLine scaledAdd(FLine With){
FLine result = operator(With,SCALEDADD);
result.norm();
return result;
}
/** computes the difference from this FLine and With */
public FLine difference(FLine With){
return operator(With,SUBTRACT);
}
/** computes the scaled difference from this FLine and With */
public FLine scaledDifference(FLine With){
FLine result = operator(With,SCALEDDIFFERENCE);
result.norm();
return result;
}
/**
* computes the alpha-cut of this FLine
* i.e. removes all FSegments whith a middle membershipvalue
* less (less or equal) as alpha
*/
public FLine alphaCut(double alpha, boolean strong){
FLine CutL = new FLine(SF);
fSegment Current;
boolean isValid;
double midZ;
for(int i=0; i<fSeg.getSize(); i++){
Current = (fSegment) fSeg.get(i);
midZ = (Current.getZ1()+ Current.getZ2())/2;
if (strong)
isValid = midZ>alpha;
else
isValid = midZ>= alpha;
if(isValid)
CutL.fSeg.insert(Current.copy());
}
CutL.computeBoundingBox();
return CutL;
}
/**
* computes the length of the basic of this FLine
*/
public double basicLen(){
double sum = 0.0;
for(int i=0;i<fSeg.getSize();i++){
sum += ((BasicSegment) fSeg.get(i).basic()).length();
}
return sum;
}
/**
* computes the len of the 3d-structure of this FLine
*/
public double len3D(){
double sum = 0.0;
for(int i=0;i<fSeg.getSize();i++){
sum += ((fSegment) fSeg.get(i)).length();
}
return sum;
}
/**
* computes the weigthed length of this FLine
*/
public double length(){
double sum = 0.0;
double Z;
fSegment Current;
for(int i=0;i<fSeg.getSize();i++){
Current = (fSegment) fSeg.get(i);
Z = (Current.getZ1() + Current.getZ2())/2;
sum += Z*( (BasicSegment) Current.basic()).length();
}
return sum;
}
/**
* computes how similar is the basic of 2 FLines
*/
public double basicSimilar(FLine L2){
FLine Funion = this.union(L2);
FLine Fintersection = this.intersection(L2);
if (Funion.isEmpty())
return 1.0;
else
return Fintersection.basicLen() / Funion.basicLen();
}
/**
* how similar are 2 FLines ?
*/
public double similar(FLine L2){
FLine Funion = this.union(L2);
FLine Fintersection = this.intersection(L2);
if (Funion.isEmpty())
return 1.0;
else
return Fintersection.length() / Funion.length();
}
/**
* make this FLine sharp
* i.e. the membershipvalues of the result are ever 1.0
*/
public FLine sharp(){
FLine result = new FLine(1);
fSegment CurrentSegment;
for(int i=0;i<fSeg.getSize();i++){
CurrentSegment = new fSegment(
(BasicSegment)
(fSeg.get(i).basic()),1,1);
result.add(CurrentSegment);
}
return result;
}
/**
* computes the boundary of this FLine
*/
public FPoint boundary(){
return endPoints();
}
/**
* computes the boundary of this FLine
*/
public FPoint endPoints(){
FPoint result = new FPoint(1);
BasicSegment current;
BasicPoint EP1;
BasicPoint EP2;
BasicPoint[] Neightboors;
boolean found;
for(int i=0;i<fSeg.getSize();i++){
// a endPoint of each segment is a candidate
current = (BasicSegment) fSeg.get(i).basic();
EP1 = current.getEP1();
EP2 = current.getEP2();
// check EP1
Neightboors = EP1.getNeightboors();
found=false;
for(int j=0;j<Neightboors.length&!found;j++){
if(!EP2.equals(Neightboors[j])) {
// exclude current Basicsegment
found = fSeg.search(
new BasicSegment(EP1,Neightboors[j]))!=null;
}
}
if(!found) // EP1 is a endpoint
result.add(new fEPoint(EP1,1));
// check EP2
Neightboors = EP2.getNeightboors();
found=false;
for(int j=0;j<Neightboors.length&!found;j++){
if(!EP1.equals(Neightboors[j])) {
found = fSeg.search(
new BasicSegment(EP2,Neightboors[j]))!=null;
}
}
if(!found) // EP2 is a endpoint
result.add(new fEPoint(EP2,1));
}
return result;
}
/**
* computed the maximal connected part of this FLine
* containing FS
*/
private void getComponent(fSegment FS, FLine result){
// computes a connected part of a line
BasicSegment BS = (BasicSegment) FS.basic();
result.add(FS);
BasicSegment[] Neightboors = BS.getNeightboors();
for(int i=0;i<Neightboors.length;i++) {
if(result.fSeg.getPos(Neightboors[i])<0){ // not in result
fSegment NB = (fSegment) this.fSeg.search(Neightboors[i]);
if(NB!=null){
getComponent(NB,result);
}
}
}
}
public boolean equals(FLine L2){
return fSeg.equals(L2.fSeg) & SF==L2.SF;
}
/**
* computes the connected parts of this FLine
*/
public FLine[] faces(){
if(isEmpty()) return null;
Vector tmp = new Vector(); // for the faces ;
// use Vector hence number of faces unknow
FLine Copy = this.copy();
while( ! Copy.isEmpty()){
FLine nextFace = new FLine(SF);
fSegment First = (fSegment) Copy.fSeg.get(0);
getComponent(First,nextFace);
tmp.add(nextFace);
Copy = Copy.difference(nextFace);
}
FLine[] result = new FLine[tmp.size()];
for(int i=0;i<tmp.size();i++)
result[i] = (FLine) tmp.get(i);
return result;
}
/**
* check whether this FLine contains BP
*/
public boolean contains(BasicPoint BP){
// returns true, if BP a Point of this Line
return numberOfSegments(BP)>0;
}
/**
* check whether BP is on boundary of this FLine
*/
public boolean isEndPoint(BasicPoint BP){
return numberOfSegments(BP)==1;
}
/**
* returns the number of Basicsegments containing in this FLine
* having BP as endpoint
*/
public int numberOfSegments(BasicPoint BP){
BasicPoint[] Neightboors = BP.getNeightboors();
int found =0;
for(int i=0;i<Neightboors.length;i++)
if (fSeg.search(new BasicSegment(BP,Neightboors[i]))!=null)
found ++;
return found;
}
/**
* a implementation of the mid-operator for a set of FLines
*/
public static FLine mid(FLine[] Lns){
if(Lns.length==0) return null;
FLine result = new FLine(1);
int[] current = new int[Lns.length];
int[] max = new int[Lns.length];
boolean[] ready = new boolean[Lns.length];
boolean allready = true;
// initialize the variables
for(int i=0;i<Lns.length;i++){
current[i]=0;
max[i]= Lns[i].fSeg.getSize();
ready[i] = current[i]<max[i];
if(!ready[i]) allready=false;
}
Vector allSmallest = new Vector(); // the smallest Segments
Vector Numbers = new Vector(); // the positions in Lns
while(!allready){
allready=true;
allSmallest = new Vector();
Numbers = new Vector();
// search all smallest Segment
fSegment currentS;
BasicSegment compareS;
for(int i=0;i<Lns.length;i++){
if(current[i]<max[i]) {
allready=false;
currentS = (fSegment) Lns[i].fSeg.get(current[i]);
if(allSmallest.size()==0) {
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
else {
compareS = (BasicSegment)
((fSegment) allSmallest.get(0)).basic();
int comp = currentS.basic().compareTo(compareS);
if(comp==0) { // a Segement with smallest Basic
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
if(comp<0) { // new smallest Segment
allSmallest = new Vector();
Numbers = new Vector();
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
// in the case comp>0 is nothing to do
} // not the first Segment
} // current Line contains unprocessing Segments
} // for all Lines
if(!allready){
double Z1=0,Z2=0;
BasicSegment BS = (BasicSegment)
((fSegment) allSmallest.get(0)).basic();
fSegment CS;
for(int i=0;i<allSmallest.size();i++){
// update numbers
int c = ((Integer)Numbers.get(i)).intValue();
current[c]++;
CS = (fSegment) allSmallest.get(i);
Z1 += CS.getZ1();
Z2 += CS.getZ2();
}
Z1 = Z1 / Lns.length;
Z2 = Z2 / Lns.length;
result.fSeg.insert( new fSegment(BS,Z1,Z2));
}
} // while not all ready
result.computeBoundingBox();
return result;
}
/**
* a implementation of the scaled mid
* operator for a set of FLines
*/
public static FLine scaledMid(FLine[] Lns){
if(Lns.length==0) return null;
FLine result = new FLine(1);
int[] current = new int[Lns.length];
int[] max = new int[Lns.length];
boolean[] ready = new boolean[Lns.length];
boolean allready = true;
// initialize the variables
for(int i=0;i<Lns.length;i++){
current[i]=0;
max[i]= Lns[i].fSeg.getSize();
ready[i] = current[i]<max[i];
if(!ready[i]) allready=false;
}
Vector allSmallest = new Vector(); // the smallest Segments
Vector Numbers = new Vector(); // the positions in Lns
while(!allready){
allready=true;
allSmallest = new Vector();
Numbers = new Vector();
// search all smallest Segment
fSegment currentS;
BasicSegment compareS;
for(int i=0;i<Lns.length;i++){
if(current[i]<max[i]) {
allready=false;
currentS = (fSegment) Lns[i].fSeg.get(current[i]);
if(allSmallest.size()==0) {
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
else {
compareS = (BasicSegment)
((fSegment) allSmallest.get(0)).basic();
int comp = currentS.basic().compareTo(compareS);
if(comp==0) { // a Segement with smallest Basic
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
if(comp<0) { // new smallest Segment
allSmallest = new Vector();
Numbers = new Vector();
allSmallest.add(currentS);
Numbers.add(new Integer(i));
}
// in the case comp>0 is nothing to do
} // not the first Segment
} // current Line contains unprocessing Segments
} // for all Lines
if(!allready){
double Z1=0,Z2=0;
BasicSegment BS = (BasicSegment)
((fSegment) allSmallest.get(0)).basic();
fSegment CS;
for(int i=0;i<allSmallest.size();i++){
// update numbers
int c = ((Integer)Numbers.get(i)).intValue();
current[c]++;
CS = (fSegment) allSmallest.get(i);
Z1 += CS.getZ1()*Lns[c].SF;
Z2 += CS.getZ2()*Lns[c].SF;
}
Z1 = Z1 / Lns.length;
Z2 = Z2 / Lns.length;
result.fSeg.insert( new fSegment(BS,Z1,Z2));
}
} // while not all ready
result.norm();
result.computeBoundingBox();
return result;
}
/**
* computes the common points of 2 FLines
* i.e. Points containing in this and L2 <b>and </b>
* not endpoint of a common segment of this FLines
*/
public FPoint commonPoints(FLine L2){
FPoint result = new FPoint();
FLine SI = operator(L2,SHARPINTERSECTION);
BasicSegment current;
BasicPoint BP1,BP2;
for(int i=0;i<fSeg.getSize();i++){
current = (BasicSegment) fSeg.get(i).basic();
BP1 = current.getEP1();
BP2 = current.getEP2();
if ( L2.contains(BP1) && // a common point
!SI.contains(BP1) ) // not a point of a common Line
result.add(new fEPoint(BP1,1));
if( L2.contains(BP2) &&
!SI.contains(BP2) )
result.add(new fEPoint(BP2,1));
} // for
return result;
}
/************************************************************
end of operators
*************************************************************/
/** process a single Segment for many operators */
private void processElements(fSegment F1, double scale1,
fSegment F2, double scale2,
FLine Goal,
int Operator){
// 1 input parameter can be null
// if both fTriangles not null, then they must
// have the same basic
if( F1==null & F2==null) return;
double Z1,Z2;
fSegment newFS;
switch (Operator){
case UNION : { // the union of 2 Lines ignoring SFs
if(F1==null)
Goal.fSeg.insert(F2.copy());
else if(F2==null)
Goal.fSeg.insert(F1.copy());
else { // both fTriangles are not null
Z1 = Math.max(F1.getZ1(),F2.getZ1());
Z2 = Math.max(F1.getZ2(),F2.getZ2());
newFS = new fSegment((BasicSegment)
F1.basic(),
Z1,Z2);
Goal.fSeg.insert(newFS);
} // else
}
break;
case INTERSECTION : {
if (F1==null | F2==null)
;
else { // both are not null
Z1 = Math.min(F1.getZ1(),F2.getZ1());
Z2 = Math.min(F1.getZ2(),F2.getZ2());
if(Z1+Z2>0){
newFS = new fSegment((BasicSegment)
F1.basic(),
Z1,Z2 );
Goal.fSeg.insert(newFS);
}
}
}
break;
case ADD : {
if(F1==null)
Goal.fSeg.insert(F2.copy());
else
if(F2==null)
Goal.fSeg.insert(F1.copy());
else { // both fSegments are not null
Z1 = Math.min(1,F1.getZ1()+F2.getZ1());
Z2 = Math.min(1,F1.getZ2()+F2.getZ2());
newFS = new fSegment((BasicSegment)
F1.basic(),
Z1,Z2);
Goal.fSeg.insert(newFS);
} // else
}
break;
case SUBTRACT :{
if(F1 == null)
;
else if(F2==null)
Goal.fSeg.insert(F1.copy());
else { // both not null
Z1 = Math.max(0,F1.getZ1()-F2.getZ1());
Z2 = Math.max(0,F1.getZ2()-F2.getZ2());
if ((Z1+Z2)>0) {
newFS = new fSegment( (BasicSegment)
F1.basic(),Z1,Z2);
Goal.fSeg.insert(newFS);
}
}
} break;
case SCALEDUNION : {
fSegment newSegment;
if (F1==null)
newSegment = new fSegment( (BasicSegment)
F2.basic(),
F2.getZ1()*scale2,
F2.getZ2()*scale2);
else if (F2==null)
newSegment = new fSegment( (BasicSegment)
F1.basic(),
F1.getZ1()*scale1,
F1.getZ2()*scale1);
else {
Z1 = Math.max(F1.getZ1()*scale1,
F2.getZ1()*scale2);
Z2 = Math.max(F1.getZ2()*scale1,
F2.getZ2()*scale2);
newSegment = new fSegment( (BasicSegment)
F1.basic(),
Z1,Z2);
} // else
Goal.add(newSegment);
}
break; // scaled union
case SCALEDINTERSECTION :
if (F1==null || F2==null)
;
else {
Z1 = Math.min(F1.getZ1()*scale1,
F2.getZ1()*scale2);
Z2 = Math.min(F1.getZ2()*scale1,
F2.getZ2()*scale2);
Goal.add(new fSegment( (BasicSegment)
F1.basic(),
Z1,Z2));
}
break;
case SCALEDADD : {
if(F1==null)
Goal.add(new fSegment( (BasicSegment)
F2.basic(),
F2.getZ1()*scale2,
F2.getZ2()*scale2));
else if(F2==null)
Goal.add(new fSegment( (BasicSegment)
F1.basic(),
F1.getZ1()*scale1,
F1.getZ2()*scale1));
else {
Goal.add(new fSegment( (BasicSegment)
F1.basic(),
F1.getZ1()*scale1 +
F2.getZ1()*scale2 ,
F1.getZ2()*scale1 +
F2.getZ2()*scale2 ));
}
}
break;
case SCALEDDIFFERENCE : {
if(F1==null)
Goal.add(new fSegment( (BasicSegment)
F2.basic(),
-F2.getZ1()*scale2,
-F2.getZ2()*scale2));
else if(F2==null)
Goal.add(new fSegment( (BasicSegment)
F1.basic(),
F1.getZ1()*scale1,
F1.getZ2()*scale1));
else {
Goal.add(new fSegment( (BasicSegment)
F1.basic(),
F1.getZ1()*scale1 -
F2.getZ1()*scale2 ,
F1.getZ2()*scale1 -
F2.getZ2()*scale2 ));
}
}
break;
case SHARPINTERSECTION :{
if (F1==null | F2==null)
;
else {
newFS = new fSegment((BasicSegment)F1.basic(),1,1);
Goal.fSeg.insert(newFS);
}
}
break;
default : System.err.println("operator not implemented");
} // switch
} // processElements
/** the 'template' for many operators */
protected FLine operator(FLine FL, int op){
// a kind of mergesort
int my = 0;
int fromFL = 0; // already processed
int maxMy = fSeg.getSize(); // numbers of elements
int maxFromFL = FL.fSeg.getSize();
FLine result = new FLine(1);
fSegment myFirst=null; // the first unprocessed elements
fSegment FLFirst=null;
if(maxMy>0)
myFirst = (fSegment) fSeg.get(0);
if(maxFromFL>0)
FLFirst = (fSegment) FL.fSeg.get(0);
if (maxMy >0 && maxFromFL>0){
myFirst = (fSegment) fSeg.get(my);
FLFirst = (fSegment) FL.fSeg.get(fromFL);
int compareResult;
while(my<maxMy && fromFL<maxFromFL){
// both sets have unprocessed elements
compareResult=myFirst.basic().compareTo(FLFirst.basic());
if(compareResult < 0) {
processElements(myFirst,SF,null,FL.SF,result,op);
my++;
if (my<maxMy)
myFirst = (fSegment) fSeg.get(my);
}
else if(compareResult > 0){
processElements(null,SF,FLFirst,FL.SF,result,op);
fromFL++;
if(fromFL<maxFromFL)
FLFirst = (fSegment) FL.fSeg.get(fromFL);
}
else { // elements have the same basic
processElements(myFirst,SF,FLFirst,FL.SF,result,op);
my++;
fromFL++;
if (my<maxMy)
myFirst = (fSegment) fSeg.get(my);
if (fromFL<maxFromFL)
FLFirst = (fSegment) FL.fSeg.get(fromFL);
}
} // while
} // if
// elements from one (or both) regions are processed
while(my < maxMy){ // this have still elements
processElements(myFirst,SF,null,FL.SF,result,op);
my++;
if (my<maxMy)
myFirst = (fSegment) fSeg.get(my);
}
while (fromFL < maxFromFL){ // FL have still elements
processElements(null,SF,FLFirst,FL.SF,result,op);
fromFL++;
if(fromFL<maxFromFL)
FLFirst = (fSegment) FL.fSeg.get(fromFL);
}
result.computeBoundingBox();
return result;
}
/** normalize this FLine */
private void norm(){
if (isEmpty()) return; // nothing to do
// first compute Zmin and Zmax
double Zmin = 0;
double Zmax = 0;
fSegment Current;
for (int i=0; i< fSeg.getSize();i++){
Current = (fSegment) fSeg.get(i);
if(Current.getMaxZ()>Zmax)
Zmax = Current.getMaxZ();
if(Current.getMinZ()<Zmin)
Zmin = Current.getMinZ();
}
if(Zmin > 0) Zmin=0;
if(Zmax==0 & Zmin==0)
fSeg.makeEmpty();
else{
double SFnew = Zmax - Zmin;
SortedObjects newfSeg = new SortedObjects();
double Z1,Z2,Z3;
fSegment fSnew;
for(int i=0;i<fSeg.getSize();i++){
Current = (fSegment) fSeg.get(i);
Z1 = Current.getZ1();
Z2 = Current.getZ2();
fSnew = new fSegment( (BasicSegment) Current.basic(),
(Z1-Zmin)/SFnew ,
(Z2-Zmin)/SFnew );
if (fSnew.getMaxZ() >0)
newfSeg.insert(fSnew);
} // for
SF = SFnew*SF;
fSeg = newfSeg;
}
computeBoundingBox();
}
/*************************************************************
* *
* topological Relationships *
* *
*************************************************************/
/*************************************************************
* *
* Topology in the basic *
* *
*************************************************************/
/** helping method to compute the top Rel in the basic */
private static void checkPointsBasic(
int Segs1, int Segs2,
M9Int goal ){
/* this method checks the intersection of two lines in a
BasicPoint BP
Paramters :
Segs1, Segs2 : numberOfSegments of each Line in BP
Z1,Z2 : maxZfkt(BP) for each Line
fuzzy : basic or fuzzy intersections ?
goal : here saving the result(s)
*/
if(Segs1==0) { // exterior of L1
if(Segs2==0) // exterior
goal.setValue(true,M9Int.EXTERIOR,M9Int.EXTERIOR);
if(Segs2==1) // boundary
goal.setValue(true,M9Int.EXTERIOR,M9Int.BOUNDARY);
if(Segs2>1){ // interior
goal.setValue(true,M9Int.EXTERIOR,M9Int.INTERIOR);
} // interior of l2
} // exterior of L1
if(Segs1==1) { // boundary of L1
if(Segs2==0)
goal.setValue(true,M9Int.BOUNDARY,M9Int.EXTERIOR);
if(Segs2==1)
goal.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
if(Segs2>1){ // interior of L2
goal.setValue(true,M9Int.BOUNDARY,M9Int.INTERIOR);
}// interior of L2
} // boundary of L1
if(Segs1>1) { // a interior Point of Line 1
if(Segs2==0){
goal.setValue(true,M9Int.INTERIOR,M9Int.EXTERIOR);
} // Segs1==0
if(Segs2==1){ // boundary of L2
goal.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
} // boundary of L2
if(Segs2>1){ // intersection of both interiors
goal.setValue(true,M9Int.INTERIOR,M9Int.INTERIOR);
} // both interiors
} // interior of L1
} // checkPointsBasic
/** helping method to compute top Rel in the basic */
private static void checkEndPoints(FLine L1,FLine L2,
BasicPoint BP,
M9Int goal){
int Segs1 = L1.numberOfSegments(BP);
int Segs2 = L2.numberOfSegments(BP);
checkPointsBasic(Segs1,Segs2,goal);
}
/**
* computed the 9-Intersection-matrix from this FLine and L2
*/
M9Int basicTopolRelation(FLine L2){
M9Int result = new M9Int();
if (this.isEmpty() || L2.isEmpty()) return null;
result.setValue(true,M9Int.EXTERIOR,M9Int.EXTERIOR);
int currentThis=0;
int currentL2=0;
int maxThis = fSeg.getSize();
int maxL2 = L2.fSeg.getSize();
fSegment thisFirst;
fSegment L2First;
BasicSegment thisBasic;
BasicSegment L2Basic;
BasicSegment Smallest=null;
BasicPoint BP1,BP2;
int compare;
int thisSegs;
int L2Segs;
while(currentThis<maxThis & currentL2<maxL2){
thisFirst = (fSegment) fSeg.get(currentThis);
L2First = (fSegment) L2.fSeg.get(currentL2);
thisBasic = (BasicSegment) thisFirst.basic();
L2Basic = (BasicSegment) L2First.basic();
compare = (thisBasic.compareTo(L2Basic));
if( compare==0) { // a common Segment
currentThis++;
currentL2++;
result.setValue(true,M9Int.INTERIOR,M9Int.INTERIOR);
Smallest=thisBasic; // special role of endpoints
}
if(compare < 0) { // process single segment of this
result.setValue(true,M9Int.INTERIOR,M9Int.EXTERIOR);
Smallest=thisBasic;
currentThis++;
}
if(compare > 0) { // process single Segment of L2
result.setValue(true,M9Int.EXTERIOR,M9Int.INTERIOR);
Smallest=L2Basic;
currentL2++;
}
// process Endpoints of Segment(s)
BP1 = Smallest.getEP1();
BP2 = Smallest.getEP2();
checkEndPoints(this,L2,BP1,result);
checkEndPoints(this,L2,BP2,result);
}// while
while(currentThis<maxThis){
thisFirst = (fSegment) fSeg.get(currentThis);
currentThis++;
thisBasic = (BasicSegment) thisFirst.basic();
result.setValue(true,M9Int.INTERIOR,M9Int.EXTERIOR);
BP1 = thisBasic.getEP1();
BP2 = thisBasic.getEP2();
checkEndPoints(this,L2,BP1,result);
checkEndPoints(this,L2,BP2,result);
}
while(currentL2<maxL2){
L2First = (fSegment) L2.fSeg.get(currentL2);
currentL2++;
L2Basic = (BasicSegment) L2First.basic();
result.setValue(true,M9Int.EXTERIOR,M9Int.INTERIOR);
BP1 = L2Basic.getEP1();
BP2 = L2Basic.getEP2();
checkEndPoints(this,L2,BP1,result);
checkEndPoints(this,L2,BP2,result);
}
return result;
} // basicTopolRelation
/** computes the 9-intersection-matrix from this and R */
M9Int basicTopolRelation(FRegion R){
M9Int result = new M9Int();
// the 'defaults'
result.setValue(true,M9Int.EXTERIOR,M9Int.EXTERIOR);
result.setValue(true,M9Int.EXTERIOR,M9Int.INTERIOR);
fSegment currentSeg;
BasicSegment currentBS;
int TriNumberSeg;
int SegNumber1,SegNumber2;
BasicPoint BP1,BP2;
boolean onBound1,onBound2;
for(int i=0;i<fSeg.getSize();i++){
currentSeg = (fSegment) fSeg.get(i);
currentBS = (BasicSegment) currentSeg.basic();
BP1 = currentBS.getEP1();
BP2 = currentBS.getEP2();
SegNumber1 = numberOfSegments(BP1);
SegNumber2 = numberOfSegments(BP2);
TriNumberSeg = R.numberOfTriangles(currentBS);
onBound1 = R.onBoundary(BP1);
onBound2 = R.onBoundary(BP2);
if(TriNumberSeg==0) { //segment is in exterior of R
result.setValue(true,M9Int.INTERIOR,M9Int.EXTERIOR);
if(onBound1){
if(SegNumber1==1)
result.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
else // a interior point of the Line
result.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
} // onBound1
if(onBound2) {
if(SegNumber2==1)
result.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
else
result.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
} // onBound2
} // TriNumberSeg==0
if(TriNumberSeg==1) { // Segment on boundary of R
result.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
if(SegNumber1==1 | SegNumber2==1)
result.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
}
if(TriNumberSeg==2){ // Segment in interior of R
result.setValue(true,M9Int.INTERIOR,M9Int.INTERIOR);
if(onBound1){
if(SegNumber1==1)
result.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
else // a interior point of the Line
result.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
} // onBound1
if(onBound2) {
if(SegNumber2==1)
result.setValue(true,M9Int.BOUNDARY,M9Int.BOUNDARY);
else
result.setValue(true,M9Int.INTERIOR,M9Int.BOUNDARY);
} // onBound2
} // TriNumberSeg==2
}
// a boundary-Segment of R in exterior of L
FLine RegionBoundary = R.boundary();
boolean found=false;
for(int i=0;i<RegionBoundary.fSeg.getSize() & !found;i++){
currentBS = (BasicSegment) RegionBoundary.fSeg.get(i).basic();
if (fSeg.search(currentBS)==null){
result.setValue(true,M9Int.INTERIOR,M9Int.EXTERIOR);
found = true;
}
}
return result;
}
/** compute the 9-intersection-matrix from this and CO */
public M9Int basicTopolRelation(CompositeObject CO){
if(CO instanceof FPoint){
M9Int result = (( (FPoint)CO).basicTopolRelation(this));
result.makeSym();
return result;
}
if(CO instanceof FLine)
return basicTopolRelation( (FLine) CO);
if(CO instanceof FRegion)
return basicTopolRelation( (FRegion) CO);
return null;
}
/**********************************************************
*
* Topology of fuzzy objects
*
**********************************************************/
/**
* returns the membership-value on given pos on a given
* BasicSegment <br>
* pos must be in [0,1]
*/
double getMaxValue(BasicSegment BS, double pos){
if(pos<0 || pos>1)
return 0;
fSegment FS = (fSegment) fSeg.search(BS);
if(FS==null)
return 0;
double Z1,Z2;
Z1 = FS.getZ1();
Z2 = FS.getZ2();
return Z1+pos*(Z2-Z1);
}
/** compute the top Rel between this and L */
public FuzzyTopRel topolRelation(FLine L){
int currentThis=0;
int currentL=0;
int maxThis=fSeg.getSize();
int maxL = fSeg.getSize();
fSegment fST,fSL;
BasicSegment BST,BSL;
int compare;
BasicPoint BP1,BP2;
double Z1T,Z2T,Z1L,Z2L;
FuzzyTopRel result = new FuzzyTopRel();
while(currentThis<maxThis & currentL<maxL){
fST = (fSegment) fSeg.get(currentThis);
BST = (BasicSegment) fST.basic();
fSL = (fSegment) fSeg.get(currentL);
BSL = (BasicSegment) fSL.basic();
compare = BST.compareTo(BSL);
if(compare<0){ // test on boundary of L
currentThis++;
BP1 = BST.getEP1();
BP2 = BST.getEP2();
if(L.contains(BP1)){
Z1T = fST.getZ1();
Z1L = L.maxZfkt(BP1);
result.computeValue(Z1T,Z1L);
}
if(L.contains(BP2)){
Z1T = fST.getZ2();
Z1L = L.maxZfkt(BP2);
result.computeValue(Z1T,Z1L);
}
}
if(compare>0){ // test on boundary of this
currentL++;
BP1 = BSL.getEP1();
BP2 = BSL.getEP2();
if(this.contains(BP1)){
Z1L = fSL.getZ1();
Z1T = this.maxZfkt(BP1);
result.computeValue(Z1T,Z1L);
}
if(this.contains(BP2)){
Z1L = fSL.getZ2();
Z1T = this.maxZfkt(BP2);
result.computeValue(Z1T,Z1L);
}
}
if(compare==0){ // common segment
currentL++;
currentThis++;
Z1T = fST.getZ1();
Z2T = fST.getZ2();
Z1L = fSL.getZ1();
Z2L = fSL.getZ2();
if( Z1T==Z1L | Z2T==Z2L){
result.computeValue(Z1T,Z1L);
result.computeValue(Z2T,Z2L);
}
else{
if( (Z1T>Z1L & Z2T>Z2L) | (Z1T<Z1L & Z2T<Z2L) )
result.computeValue(Z1T,Z1L);
else{ // the functions are crossing
result.computeValue(Z1T,Z1L);
result.computeValue(Z2T,Z2L);
result.computeValue(0.5,0.5); // the intersection
if(Z1T==0 | Z2T==0)
result.computeValue(0.1,0.2);
if(Z1L==0 | Z2L==0)
result.computeValue(0.2,0.1);
} // else
} // else
} // compare==0
} // while
while(currentThis<maxThis){
fST = (fSegment) fSeg.get(currentThis);
BST = (BasicSegment) fST.basic();
BP1 = BST.getEP1();
BP2 = BST.getEP2();
currentThis++;
if(L.contains(BP1)) {
Z1T = fST.getZ1();
Z1L = L.maxZfkt(BP1);
result.computeValue(Z1T,Z1L);
}
if(L.contains(BP2)){
Z1T = fST.getZ2();
Z1L = L.maxZfkt(BP2);
result.computeValue(Z1T,Z1L);
}
}
while(currentL<maxL){
fSL = (fSegment) fSeg.get(currentL);
BSL = (BasicSegment) fSL.basic();
BP1 = BSL.getEP1();
BP2 = BSL.getEP2();
currentL++;
if(this.contains(BP1)){
Z1L = fSL.getZ1();
Z1T = this.maxZfkt(BP1);
result.computeValue(Z1T,Z1L);
}
if(this.contains(BP2)){
Z1L = fSL.getZ2();
Z1T = this.maxZfkt(BP2);
result.computeValue(Z1T,Z1L);
}
} // while
return result;
} // topolRelation
/** computes the top Rel between this Line and R */
public FuzzyTopRel topolRelation(FRegion R){
FuzzyTopRel result = new FuzzyTopRel();
int max = fSeg.getSize();
fSegment FS;
BasicSegment BS;
BasicPoint BP1,BP2;
double Z1L,Z2L,Z1R,Z2R;
for(int current=0;current<max;current++){
FS = (fSegment) fSeg.get(current);
BS = (BasicSegment) FS.basic();
BP1 = BS.getEP1();
BP2 = BS.getEP2();
Z1L = FS.getZ1();
Z2L = FS.getZ2();
if(R.contains(BS)){
double values[] = R.getValues(BS);
if(values.length==2){
Z1R = values[0];
Z2R = values[1];
if(Z1L!=Z1R) // only inner values
result.computeValue(Z1L,Z1R);
if(Z2L!=Z2R) // only inner values
result.computeValue(Z2L,Z2R);
if( (Z1L-Z1R)*(Z2L-Z2R)<0 ) // crossing => equal value
result.computeValue(0.5,0.5);
if( (Z1L==Z1R) & (Z2L==Z2R) ) // equals segments
result.computeValue(0.5,0.5);
}
else{
// in the regions exists crossing triangles over this BS
Z1R = values[0];
Z2R = values[1];
double ZMR = values[3];
double ZML = Z1L + values[2]*(Z2L-Z1L);
if(Z1L!=Z1R) // only inner values
result.computeValue(Z1L,Z1R);
result.computeValue(ZML,ZMR);
if(Z2L!=Z2R)
result.computeValue(Z2L,Z2R);
if( ((Z1L-Z1R)*(ZML-ZMR)<0) || ((ZML-ZMR)*(Z2L-Z2R)<0) )
result.computeValue(0.5,0.5);
}
} // R contains Segment
if(R.contains(BP1)){
Z1R = R.maxZfkt(BP1);
result.computeValue(Z1L,Z1R);
}
if(R.contains(BP2)){
Z2R = R.maxZfkt(BP2);
result.computeValue(Z2L,Z2R);
}
} // for
return result;
}
/** computes the top.rel. between this and CO */
public FuzzyTopRel topolRelation(CompositeObject CO){
FuzzyTopRel result;
if(CO instanceof FPoint){
result = ((FPoint) CO).topolRelation(this);
result.makeSym();
return result;
}
if(CO instanceof FLine)
return topolRelation((FLine) CO);
if(CO instanceof FRegion)
return topolRelation((FRegion) CO);
return null;
}
/** returns the ListExpr representation of this FLine
* (SF , (<SegmentList>))
*/
public ListExpr toListExpr(){
// first create the SegmentList
ListExpr Segments;
ListExpr Last=null;
if(fSeg.getSize()==0)
Segments = ListExpr.theEmptyList();
else {
Segments = ListExpr.oneElemList(
((fSegment)fSeg.get(0)).toListExpr());
Last = Segments;
}
fSegment NextSegment;
for(int i=1;i<fSeg.getSize();i++){
NextSegment = (fSegment) fSeg.get(i);
Last=ListExpr.append(Last,NextSegment.toListExpr());
}
return ListExpr.twoElemList(
ListExpr.realAtom((float)SF),Segments);
}
/** creates a new ListEXpr <type,value>*/
public ListExpr toTypedListExpr(){
return ListExpr.twoElemList(
ListExpr.symbolAtom("fline"),toListExpr());
}
/** read this FLine from a ListExpr
* @return true if LE is a valid Representaion of a FLine
* all valid Segments of this List are inserted
*/
public boolean readFromListExpr(ListExpr LE){
SF = 1.0;
fSeg.makeEmpty();
computeBoundingBox();
if(LE==null)
return false;
if(LE.listLength()!=2)
return false;
ListExpr SFList = LE.first();
if( !( SFList.isAtom() && (SFList.atomType()==ListExpr.INT_ATOM
|| SFList.atomType()==ListExpr.REAL_ATOM)))
return false;
double z= SFList.atomType()==ListExpr.INT_ATOM ?
SFList.intValue() :
SFList.realValue();
if(z<=0)
return false;
this.SF = z;
ListExpr Segments = LE.second();
fSegment S;
boolean ok = true;
while( !Segments.isEmpty() & ok) {
S = new fSegment(0,0,0,0,0,0);
if(S.readFromListExpr(Segments.first())){
add(S);
Segments=Segments.rest();
}
else
ok = false;
}
return ok;
}
/** returns a String representation of
* the corresponding ListExpr
*/
public String toListString(){
return toListExpr().writeListExprToString();
}
/** read the FLine from a String representation of a ListExpr
* @return true if List is a String of a ListExpr
* containing a correct FLine
*/
public boolean readFromListString(String List){
ListExpr LE = new ListExpr();
if(LE.readFromString(List)!=0){
return false;
}
else{
return readFromListExpr(LE);
}
}
/** this method is used for reading a fuzzy line
* from a byte array;
* returns null if the construction of the object failed
*/
public static FLine readFrom(byte[] buffer){
try{
ObjectInputStream ois;
ois= new ObjectInputStream(
new ByteArrayInputStream(buffer));
FLine res = (FLine) ois.readObject();
ois.close();
return res;
} catch(Exception e){
return null;
}
}
/** this method serialized an object */
public byte[] writeToByteArray(){
try{
ByteArrayOutputStream byteout;
byteout = new ByteArrayOutputStream(fSeg.getSize()*16+25);
ObjectOutputStream objectout;
objectout = new ObjectOutputStream(byteout);
objectout.writeObject(this);
objectout.flush();
byte[] res = byteout.toByteArray();
objectout.close();
return res;
} catch(Exception e){
return null;
}
}
/** computes a hash-value for this FPoint */
public int getHashValue(){
return Math.abs((BB.getMaxX()-BB.getMinX())*
(BB.getMaxY()-BB.getMinY())+BB.getMinX()
+BB.getMinY());
}
// define constants for the operators
private static final int UNION = 0;
private static final int INTERSECTION=1;
private static final int ADD=2;
private static final int SUBTRACT=3;
private static final int SCALEDUNION=4;
private static final int SCALEDINTERSECTION=5;
private static final int SCALEDADD=6;
private static final int SCALEDDIFFERENCE=7;
private static final int SHARPINTERSECTION=8;
// == intersection(sharp(L1),sharp(L2))
} // FLine;
Reference in New Issue Copy Permalink