306 lines
7.0 KiB
Java
306 lines
7.0 KiB
Java
//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.simple;
|
|
|
|
import fuzzyobjects.basic.*;
|
|
import sj.lang.ListExpr;
|
|
|
|
/**
|
|
* provides fuzzy Segments
|
|
* @author Thomas Behr
|
|
*/
|
|
|
|
public class fSegment implements SimpleObject{
|
|
|
|
/**
|
|
* creates a new fuzzy segment
|
|
* @param BP_1 a endpoint
|
|
* @param Z1 the degree of fuzziness on BP_1
|
|
* @param BP_2 a endpoint
|
|
* @param Z2 the degre of fuzziness on BP_2
|
|
*/
|
|
public fSegment( BasicPoint BP_1, double Z1,
|
|
BasicPoint BP_2, double Z2) {
|
|
|
|
if ( BP_1.compareTo(BP_2)<0) {
|
|
this.EP_1 = BP_1;
|
|
this.Z1 = Z1;
|
|
this.EP_2 = BP_2;
|
|
this.Z2 = Z2;
|
|
}
|
|
else {
|
|
this.EP_1 = BP_2;
|
|
this.Z1 = Z2;
|
|
this.EP_2 = BP_1;
|
|
this.Z2 = Z1;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* creates a new fSegment
|
|
* @param x1,y1 the location of endpoint 1
|
|
* @param Z1 degree of fuzziness of endpoint 1
|
|
* @param x2,y2 the location of the second endpoint
|
|
* @param Z2 degre of fuzziness of the second endpoint
|
|
*/
|
|
public fSegment(int x1, int y1, double Z1,
|
|
int x2, int y2, double Z2) {
|
|
this( (new BasicPoint(x1,y1)),Z1,
|
|
(new BasicPoint(x2,y2)),Z2);
|
|
}
|
|
|
|
/**
|
|
* creates a new fSegment
|
|
* @param BS the location of the new Segment
|
|
* @param Z1,Z2 the degree of fuzziness on both endpoints
|
|
*/
|
|
public fSegment(BasicSegment BS,double Z1,double Z2){
|
|
this(BS.getEP1(),Z1,BS.getEP2(),Z2);
|
|
}
|
|
|
|
/**
|
|
* returns the location of this segment
|
|
* @return the underlying Basicsegment
|
|
*/
|
|
public BasicObject basic(){
|
|
BasicSegment result = new BasicSegment(EP_1,EP_2);
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* creates a new fSegment
|
|
* @param SP_1 the first fuzzy endpoint
|
|
* @param SP_2 the second fuzzy endpoint
|
|
*/
|
|
public fSegment( fEPoint SP_1, fEPoint SP_2) {
|
|
this.EP_1 = (BasicPoint) SP_1.basic();
|
|
this.Z1 = SP_1.getZ();
|
|
this.EP_2 = (BasicPoint) SP_2.basic();
|
|
this.Z2 = SP_2.getZ();
|
|
if(EP_1.compareTo(EP_2)>0) {
|
|
BasicPoint BP = EP_1;
|
|
EP_1 = EP_2;
|
|
EP_2 = EP_1;
|
|
double Z = Z1;
|
|
Z1 = Z2;
|
|
Z2 = Z1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* returns a copy of this
|
|
* @return a new fSegment whith same
|
|
* location and fuzziness as this
|
|
*/
|
|
public fSegment copy(){
|
|
fSegment C = new fSegment(EP_1.copy(),Z1, EP_2.copy(),Z2);
|
|
return C;
|
|
}
|
|
|
|
/**
|
|
* check whether this is equal to fS
|
|
* @return true if this and fS have same
|
|
* location and fuzziness
|
|
*/
|
|
public boolean equals(fSegment fS) {
|
|
return EP_1.equals(fS.EP_1) && EP_2.equals(fS.EP_2) &&
|
|
(Z1 == fS.Z1) && (Z2 == fS.Z2);
|
|
}
|
|
|
|
/**
|
|
* check whether this and fS have the same location
|
|
* @return true if fS and this have the same underlying
|
|
* BasicSegment
|
|
*/
|
|
public boolean equalsBasic(fSegment fS) {
|
|
return this.basic().equals(fS.basic());
|
|
}
|
|
|
|
/**
|
|
* returns a readably form of this segment
|
|
* @return a String representing this segment
|
|
*/
|
|
public String toString() {
|
|
return "fS : ( (" + EP_1 + ","+Z1+") -> (" +
|
|
EP_2 + ","+Z2+"))";
|
|
}
|
|
|
|
/**
|
|
* check whether this segment is valid in the X-Triangulation
|
|
* @return true if the underlying BasicSegment is valid and
|
|
* the degrees of fuzziness are in [0,1] and exist a
|
|
* Point whith a degree greater then 0 in this segment
|
|
*/
|
|
public boolean isValid() {
|
|
if( (EP_1==null) || (EP_2==null)){
|
|
return false;
|
|
}
|
|
return EP_1.neightbooring(EP_2) && // is over a BasicLine
|
|
(Z1>=0) && (Z1<=1) && // Zi is in [0,1]
|
|
(Z2>=0) && (Z2<=1) &&
|
|
(Z1+Z2 >0); // not both Z are zero
|
|
}
|
|
|
|
/**
|
|
* returns the degree of fuzziness
|
|
* @return degree of fuzziness of the smallest point
|
|
*/
|
|
public double getZ1(){
|
|
return Z1;
|
|
}
|
|
|
|
/**
|
|
* returns the degree of fuzziness
|
|
* @return the degree of fuzziness of the greatest point
|
|
*/
|
|
public double getZ2(){
|
|
return Z2;
|
|
}
|
|
|
|
/**
|
|
* returns the smallest degree of fuzziness
|
|
*/
|
|
public double getMaxZ(){ return Math.max(Z1,Z2); }
|
|
|
|
/**
|
|
* returns the greatest degree of fuzziness
|
|
*/
|
|
public double getMinZ(){ return Math.min(Z1,Z2); }
|
|
|
|
|
|
/**
|
|
* returns the degree of fuzziness on a given point
|
|
* @params the given point
|
|
*/
|
|
public double Zfkt(BasicPoint BP){
|
|
double result=0.0;
|
|
if (BP.equals(EP_1)) result=Z1;
|
|
if (BP.equals(EP_2)) result=Z2;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* returns the degree of fuzziness on a given point
|
|
* the point must be on basic of the segment
|
|
* @param x,y the geiven Point
|
|
*/
|
|
public double Zfkt(double x, double y){
|
|
|
|
// computes the membershipvalue of this Segment in (x,y)
|
|
// no check, wether (x,y) is on the Line !!!
|
|
|
|
double delta;
|
|
double x1 = EP_1.getX();
|
|
double x2 = EP_2.getX();
|
|
double y1 = EP_1.getY();
|
|
double y2 = EP_2.getY();
|
|
|
|
if (x1!=x2)
|
|
delta = (x-x1) /(x2-x1);
|
|
else
|
|
delta = (y- y1) /(y2-y1);
|
|
|
|
return Z1+delta*(Z2-Z1);
|
|
|
|
}
|
|
|
|
/** computes the length of this segment as 3D-line*/
|
|
public double length(){
|
|
double x1 = EP_1.getX();
|
|
double y1 = EP_1.getY();
|
|
double x2 = EP_2.getX();
|
|
double y2 = EP_2.getY();
|
|
return Math.sqrt( (x2-x1)*(x2-x1) +
|
|
(y2-y1)*(y2-y1) +
|
|
(Z2-Z1)*(Z2-Z1));
|
|
}
|
|
|
|
public int getMinX(){
|
|
return Math.min(EP_1.getX(),EP_2.getX());
|
|
}
|
|
|
|
public int getMinY(){
|
|
return Math.min(EP_1.getY(),EP_2.getY());
|
|
}
|
|
|
|
public int getMaxX(){
|
|
return Math.max(EP_1.getX(),EP_2.getX());
|
|
}
|
|
|
|
public int getMaxY(){
|
|
return Math.max(EP_1.getY(),EP_2.getY());
|
|
}
|
|
|
|
|
|
/** returns the ListExpr from this fSegment */
|
|
public ListExpr toListExpr(){
|
|
fEPoint P1 = new fEPoint(EP_1,Z1);
|
|
fEPoint P2 = new fEPoint(EP_2,Z2);
|
|
return ListExpr.twoElemList(P1.toListExpr(),P2.toListExpr());
|
|
}
|
|
|
|
|
|
/** set the values of ths fSegment to LE,
|
|
* if LE represent a valid FSegment
|
|
* @return true if LE is a valid fSegment
|
|
*/
|
|
public boolean readFromListExpr(ListExpr LE){
|
|
if(LE.listLength()!=2)
|
|
return false;
|
|
fEPoint P1 = new fEPoint(0,0,0);
|
|
fEPoint P2 = new fEPoint(0,0,0);
|
|
if(!( P1.readFromListExpr(LE.first()) &&
|
|
P2.readFromListExpr(LE.second())))
|
|
return false;
|
|
BasicPoint BP1 = (BasicPoint) P1.basic();
|
|
BasicPoint BP2 = (BasicPoint) P2.basic();
|
|
if (! BP1.neightbooring(BP2))
|
|
return false;
|
|
|
|
this.EP_1 = BP1;
|
|
this.EP_2 = BP2;
|
|
this.Z1 = P1.getZ();
|
|
this.Z2 = P2.getZ();
|
|
return true;
|
|
}
|
|
|
|
/* returns the first endpoint */
|
|
public fEPoint getP1(){
|
|
return new fEPoint(EP_1,Z1);
|
|
}
|
|
|
|
/* returns the second endpoint */
|
|
public fEPoint getP2(){
|
|
return new fEPoint(EP_2,Z2);
|
|
}
|
|
|
|
|
|
/** a BasicPoint */
|
|
private BasicPoint EP_1,
|
|
EP_2;
|
|
/** degree of fuzziness */
|
|
private double Z1,Z2;
|
|
|
|
|
|
}
|
|
|