836 lines
16 KiB
C++
836 lines
16 KiB
C++
/*
|
|
----
|
|
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
|
|
----
|
|
|
|
//paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}]
|
|
//paragraph [10] Footnote: [{\footnote{] [}}]
|
|
//[TOC] [\tableofcontents]
|
|
|
|
[1] Implementation of Class Member
|
|
|
|
August-February 2015, Daniel Fuchs
|
|
|
|
[TOC]
|
|
|
|
1 Overview
|
|
|
|
This file contains the implementation of the generic class Member
|
|
and their inheriting classes for each secondo type.
|
|
|
|
1.1 Includes
|
|
|
|
*/
|
|
|
|
#include <limits>
|
|
#include <list>
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <cstdlib>
|
|
#include "Algebras/Spatial/Point.h"
|
|
#include "StandardTypes.h"
|
|
#include "StringUtils.h"
|
|
#include "Algebras/Picture/PictureAlgebra.h"
|
|
#include "Algebras/Relation-C++/RelationAlgebra.h"
|
|
#include "Algebras/GeneralTree/DistfunReg.h"
|
|
#include "Algebras/GeneralTree/PictureFuns.h"
|
|
|
|
#ifndef MEMBER_H_
|
|
#define MEMBER_H_
|
|
|
|
|
|
namespace distributedClustering{
|
|
|
|
|
|
/*
|
|
2 class ~Member~
|
|
|
|
Is a generic wrapper class for the member elements linke points etc.
|
|
|
|
*/
|
|
|
|
template <class MEMB_TYP_CLASS>
|
|
class Member{
|
|
|
|
|
|
public:
|
|
Picture* picRef;
|
|
// int* point;
|
|
std::list<MEMB_TYP_CLASS*> epsNeighborhood;
|
|
|
|
bool innerPnt; //if epsNeighborhood > minPts
|
|
|
|
bool densityReachable;
|
|
//true if one point in epsNeighborhood is a innerPnt or it is a innerPnt
|
|
// bool outerPnt;
|
|
int clusterNo,clusterType,tuplePos;
|
|
long int tupleId;
|
|
|
|
//reference to Tuple
|
|
Tuple* tuple;
|
|
|
|
|
|
/*
|
|
2.1 ~constructor~
|
|
|
|
*/
|
|
Member():innerPnt(false),densityReachable(false),
|
|
clusterNo(-1),clusterType(-1),tuplePos(0),tupleId(0){}
|
|
|
|
/*
|
|
2.2 ~addNeighbor~
|
|
|
|
Add a members addNeighbor to eps neighborhood.
|
|
|
|
*/
|
|
void addNeighbor(MEMB_TYP_CLASS* memb){
|
|
epsNeighborhood.push_back(memb);
|
|
}
|
|
|
|
/*
|
|
2.3 ~updateInnerPnt~
|
|
|
|
Check if this is a inner point wrt. eps and minPts.
|
|
|
|
*/
|
|
bool updateInnerPnt(int minPts){
|
|
if(!innerPnt){
|
|
int size = epsNeighborhood.size() ;
|
|
size >= minPts ? innerPnt =true : innerPnt= false;
|
|
}
|
|
densityReachable = innerPnt;
|
|
return innerPnt;
|
|
}
|
|
|
|
bool isInnerPoint(){
|
|
return innerPnt;
|
|
}
|
|
|
|
|
|
bool isDensityReachable(){
|
|
if(innerPnt)
|
|
densityReachable= true;
|
|
return densityReachable;
|
|
}
|
|
|
|
/*
|
|
2.4 ~updateDensityReachable~
|
|
|
|
Check if this isdensity reachable wrt. eps and minPts.
|
|
|
|
*/
|
|
bool updateDensityReachable(int minPts){
|
|
bool retVal=false;
|
|
if(innerPnt || densityReachable){
|
|
retVal=true;
|
|
}else{
|
|
typename std::list<MEMB_TYP_CLASS*>::iterator
|
|
it = epsNeighborhood.begin();
|
|
while(it!=epsNeighborhood.end() && !retVal){
|
|
if((*it)->updateInnerPnt(minPts)){
|
|
retVal=true;
|
|
}
|
|
it++;
|
|
}
|
|
}
|
|
densityReachable = retVal;
|
|
|
|
return densityReachable;
|
|
}
|
|
|
|
/*
|
|
2.5 ~existNeighbor~
|
|
|
|
Chekc if the given member is already in eps neighborhood.
|
|
|
|
*/
|
|
bool existNeighbor(MEMB_TYP_CLASS* memb){
|
|
typename std::list<MEMB_TYP_CLASS*>::iterator it = epsNeighborhood.begin();
|
|
bool exist = false;
|
|
if(this == memb){
|
|
exist=true;
|
|
}
|
|
while(it!=epsNeighborhood.end() && !exist){
|
|
if((*it)==memb)
|
|
exist = true;
|
|
else
|
|
exist = false;
|
|
it++;
|
|
}
|
|
return exist;
|
|
}
|
|
|
|
|
|
int getCountNeighbors(){
|
|
return epsNeighborhood.size();
|
|
}
|
|
|
|
/*
|
|
2.6 ~getEpsNeighborhood~
|
|
|
|
Return an iterator for the epsNeighborhood list. The committed bool value
|
|
determines if return the beginning or end of list.
|
|
|
|
*/
|
|
typename std::list<MEMB_TYP_CLASS*>::iterator getEpsNeighborhood(bool begin){
|
|
if(begin)
|
|
return epsNeighborhood.begin();
|
|
else
|
|
return epsNeighborhood.end();
|
|
}
|
|
|
|
void setClusterType(int type){
|
|
clusterType = type;
|
|
}
|
|
int getClusterType(){
|
|
return clusterType;
|
|
}
|
|
|
|
void setClusterNo(int no){
|
|
clusterNo=no;
|
|
}
|
|
|
|
int getClusterNo(){
|
|
return clusterNo;
|
|
}
|
|
|
|
bool isClusterMember(){
|
|
if(getClusterNo() < 0){
|
|
return false;
|
|
}else{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void setTuple(Tuple* tup){
|
|
tuple = tup;
|
|
}
|
|
|
|
Tuple* getTuple(){
|
|
return tuple;
|
|
}
|
|
|
|
long int getTupleId(){
|
|
return tupleId;
|
|
}
|
|
|
|
void setTupleId(long int id){
|
|
tupleId = id;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
/*
|
|
3 class ~IntMember~
|
|
|
|
Is the wrapper member class for secondo type int. Inherhit form
|
|
class Member.
|
|
|
|
*/
|
|
|
|
class IntMember : public Member<IntMember>{
|
|
private:
|
|
|
|
CcInt* point;
|
|
|
|
public:
|
|
/*
|
|
3.1 ~constructor~
|
|
|
|
*/
|
|
IntMember(): point(0){
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
IntMember(CcInt* memb) {
|
|
point= memb;
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
|
|
CcInt* getPoint(){
|
|
return point;
|
|
}
|
|
|
|
double getXVal(){
|
|
if(!point->IsDefined())
|
|
return 0;
|
|
return static_cast<double>(point->GetValue());
|
|
}
|
|
|
|
double getYVal(){
|
|
return getXVal();
|
|
}
|
|
|
|
/*
|
|
3.2 ~calcDistanz~
|
|
|
|
Calculate the distance between this and the committed point.
|
|
|
|
*/
|
|
double calcDistanz (IntMember* memb){
|
|
if(!point->IsDefined() && !(memb->getPoint())->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !(memb->getPoint())->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
double retval= memb->getXVal() - getXVal();
|
|
return retval<0 ? -retval:retval;
|
|
|
|
}
|
|
|
|
double calcDistanz(CcInt* pnt){
|
|
if(!point->IsDefined() && !pnt->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !pnt->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
|
|
double retval= pnt->GetValue() - getXVal();
|
|
return retval<0 ? -retval:retval;
|
|
|
|
}
|
|
|
|
/*
|
|
3.3 ~calcXDistanz~
|
|
|
|
Calculate the distance in the first
|
|
dimension between this and the committed point.
|
|
|
|
*/
|
|
double calcXDistanz(CcInt* pnt){
|
|
return calcDistanz(pnt);
|
|
}
|
|
|
|
void printPoint(){
|
|
cout << getXVal();
|
|
}
|
|
|
|
/*
|
|
3.4 ~getOuterLeftValue~
|
|
|
|
get the mostly left item.
|
|
|
|
*/
|
|
CcInt* getOuterLeftValue(CcInt* outerPoint, CcInt* innerPoint ){
|
|
return
|
|
innerPoint->GetValue()
|
|
> outerPoint->GetValue() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
/*
|
|
3.5 ~getOuterRightValue~
|
|
|
|
get teh mostly right item.
|
|
|
|
*/
|
|
CcInt* getOuterRightValue(CcInt* outerPoint,
|
|
CcInt* outerPointRighCl, CcInt* innerPoint ){
|
|
CcInt* retPoint = getOuterRightValue( outerPoint, innerPoint ) ;
|
|
return getOuterRightValue(outerPointRighCl,retPoint) ;
|
|
}
|
|
|
|
CcInt* getOuterRightValue(CcInt* outerPoint, CcInt* innerPoint ){
|
|
return innerPoint->GetValue()
|
|
< outerPoint->GetValue() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
/*
|
|
3.6 ~setCoordinates~
|
|
|
|
Only used for picture type.
|
|
|
|
*/
|
|
void setCoordinates(CcInt* xRef,CcInt* yRef){};
|
|
void setCoordinates(CcInt* _xRef,double _yRef){};
|
|
|
|
};
|
|
|
|
/*
|
|
4 class ~RealMember~
|
|
|
|
Is the wrapper member class for secondo type real. Inherhit form
|
|
class Member.
|
|
|
|
*/
|
|
class RealMember :public Member<RealMember>{
|
|
private:
|
|
|
|
CcReal* point;
|
|
|
|
public:
|
|
/*
|
|
4.1 ~constructor~
|
|
|
|
*/
|
|
RealMember() : point(0){
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
RealMember(CcReal* memb){
|
|
point = memb;
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
|
|
CcReal* getPoint(){
|
|
return point;
|
|
}
|
|
|
|
double getXVal(){
|
|
if(!point->IsDefined())
|
|
return 0;
|
|
return point->GetValue();
|
|
}
|
|
|
|
double getYVal(){
|
|
return getXVal();
|
|
}
|
|
|
|
/*
|
|
4.2 ~calcDistanz~
|
|
|
|
Calculate the distance between this and the committed point.
|
|
|
|
*/
|
|
double calcDistanz (RealMember* memb){
|
|
if(!point->IsDefined() && !(memb->getPoint())->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !(memb->getPoint())->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
double retval= memb->getXVal() - getXVal();
|
|
return retval<0 ? -retval:retval;
|
|
|
|
}
|
|
|
|
double calcDistanz(CcReal* pnt){
|
|
if(!point->IsDefined() && !pnt->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !pnt->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
double retval= pnt->GetValue() - getXVal();
|
|
return retval<0 ? -retval:retval;
|
|
}
|
|
|
|
/*
|
|
4.3 ~calcXDistanz~
|
|
|
|
Calculate the distance in the first
|
|
dimension between this and the committed point.
|
|
|
|
*/
|
|
double calcXDistanz(CcReal* pnt){
|
|
return calcDistanz( pnt);
|
|
}
|
|
|
|
int getCntDimensions(){
|
|
return 1;
|
|
}
|
|
|
|
void printPoint(){
|
|
cout << getXVal();
|
|
}
|
|
|
|
/*
|
|
4.4 ~getOuterLeftValue~
|
|
|
|
get the mostly left item.
|
|
|
|
*/
|
|
CcReal* getOuterLeftValue(CcReal* outerPoint, CcReal* innerPoint ){
|
|
return innerPoint->GetValue()
|
|
> outerPoint->GetValue() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
/*
|
|
4.5 ~getOuterRightValue~
|
|
|
|
get teh mostly right item.
|
|
|
|
*/
|
|
CcReal* getOuterRightValue(CcReal* outerPoint,
|
|
CcReal* outerPointRighCl, CcReal* innerPoint ){
|
|
CcReal* retPoint = getOuterRightValue( outerPoint, innerPoint ) ;
|
|
return getOuterRightValue(outerPointRighCl,retPoint) ;
|
|
}
|
|
|
|
CcReal* getOuterRightValue(CcReal* outerPoint, CcReal* innerPoint ){
|
|
return innerPoint->GetValue()
|
|
< outerPoint->GetValue() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
|
|
/*
|
|
4.6 ~setCoordinates~
|
|
|
|
Only used for picture type.
|
|
|
|
*/
|
|
void setCoordinates(CcReal* xRef,CcReal* yRef){};
|
|
void setCoordinates(CcReal* _xRef,double _yRef){};
|
|
|
|
};
|
|
|
|
/*
|
|
5 class ~PointMember~
|
|
|
|
Is the wrapper member class for secondo type point. Inherhit form
|
|
class Member.
|
|
|
|
*/
|
|
class PointMember : public Member<PointMember>{
|
|
private:
|
|
Point* point;
|
|
|
|
public:
|
|
/*
|
|
5.1 ~constructor~
|
|
|
|
*/
|
|
PointMember() : point(0){
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
PointMember(Point* memb){
|
|
point= memb;
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
}
|
|
|
|
|
|
Point* getPoint(){
|
|
return point;
|
|
}
|
|
|
|
double getXVal(){
|
|
if(!point->IsDefined())
|
|
return 0;
|
|
return point->GetX();
|
|
}
|
|
|
|
double getYVal(){
|
|
if(!point->IsDefined())
|
|
return 0;
|
|
return point->GetY();
|
|
}
|
|
|
|
/*
|
|
5.2 ~calcDistanz~
|
|
|
|
Calculate the distance between this and the committed point.
|
|
|
|
*/
|
|
double calcDistanz (PointMember* memb){
|
|
if(!point->IsDefined() && !(memb->getPoint())->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !(memb->getPoint())->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
|
|
return point->Distance(*(memb->getPoint()));
|
|
|
|
}
|
|
|
|
double calcDistanz(Point* pnt){
|
|
|
|
if(!point->IsDefined() && !pnt->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !pnt->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
return point->Distance(*pnt);
|
|
}
|
|
|
|
/*
|
|
5.3 ~calcXDistanz~
|
|
|
|
Calculate the distance in the first
|
|
dimension between this and the committed point.
|
|
|
|
*/
|
|
double calcXDistanz(Point* pnt){
|
|
|
|
if(!point->IsDefined() && !pnt->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !pnt->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
|
|
double retval= pnt->GetX() - getXVal();
|
|
return retval<0 ? -retval:retval;
|
|
|
|
}
|
|
|
|
int getCntDimensions(){
|
|
return 2;
|
|
}
|
|
|
|
void printPoint(){
|
|
cout << "("<< point->GetX()<< ", " << point->GetY() << ") ";
|
|
}
|
|
|
|
/*
|
|
5.4 ~getOuterLeftValue~
|
|
|
|
get the mostly left item.
|
|
|
|
*/
|
|
|
|
Point* getOuterLeftValue(Point* outerPoint, Point* innerPoint ){
|
|
return innerPoint->GetX()
|
|
> outerPoint->GetX() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
/*
|
|
5.5 ~getOuterRightValue~
|
|
|
|
get teh mostly right item.
|
|
|
|
*/
|
|
Point* getOuterRightValue(Point* outerPoint,
|
|
Point* outerPointRighCl, Point* innerPoint ){
|
|
Point* retPoint = getOuterRightValue( outerPoint, innerPoint ) ;
|
|
return getOuterRightValue(outerPointRighCl,retPoint) ;
|
|
}
|
|
|
|
Point* getOuterRightValue(Point* outerPoint, Point* innerPoint ){
|
|
return innerPoint->GetX() < outerPoint->GetX() ? innerPoint : outerPoint ;
|
|
}
|
|
|
|
/*
|
|
5.6 ~setCoordinates~
|
|
|
|
Only used for picture type.
|
|
|
|
*/
|
|
void setCoordinates(Point* xRef,Point* yRef){};
|
|
void setCoordinates(Point* _xRef,double _yRef){};
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
6 class ~PictureMember~
|
|
|
|
Is the wrapper member class for secondo type picture. Inherhit form
|
|
class Member.
|
|
|
|
*/
|
|
|
|
class PictureMember : public Member<PictureMember>{
|
|
private:
|
|
Picture* point, *xRef; //, *yRef;
|
|
gta::DistfunInfo df;
|
|
double xVal,yVal;
|
|
|
|
public:
|
|
/*
|
|
6.1 ~constructor~
|
|
|
|
*/
|
|
PictureMember() : point(0),xVal(0),yVal(0){
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
init();
|
|
|
|
}
|
|
|
|
PictureMember(Picture* memb):xVal(0),yVal(0){
|
|
point= memb;
|
|
innerPnt=false;
|
|
densityReachable = false;
|
|
init();
|
|
|
|
}
|
|
|
|
/*
|
|
6.2 ~init~
|
|
|
|
initalize the picture distance function.
|
|
|
|
*/
|
|
void init()
|
|
{
|
|
if(!gta::DistfunReg::isInitialized())
|
|
{
|
|
gta::DistfunReg::initialize();
|
|
}
|
|
gta::DistDataId id = gta::DistDataReg::getId(Picture::BasicType()
|
|
,gta::DistDataReg::defaultName(Picture::BasicType()));
|
|
|
|
// df = gta::DistfunReg::getInfo(gta::DFUN_DEFAULT, id);
|
|
df = gta::DistfunReg::getInfo(gta::DFUN_QUADRATIC, id);
|
|
}
|
|
|
|
|
|
|
|
Picture* getPoint(){
|
|
return point;
|
|
}
|
|
|
|
double getXVal(){
|
|
|
|
return xVal;
|
|
}
|
|
|
|
double getXValOfPic(Picture *pic){
|
|
return calcDistanz( xRef, pic);
|
|
}
|
|
|
|
double getYVal(){
|
|
return xVal;
|
|
}
|
|
|
|
/*
|
|
6.3 ~calcDistanz~
|
|
|
|
Calculate the distance between this and the committed point.
|
|
|
|
*/
|
|
double calcDistanz (PictureMember* memb){
|
|
if(!point->IsDefined() && !(memb->getPoint())->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !(memb->getPoint())->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
|
|
return calcDistanz(point,memb->getPoint());
|
|
|
|
}
|
|
|
|
double calcDistanz(Picture* pnt){
|
|
|
|
if(!point->IsDefined() && !pnt->IsDefined()){
|
|
return 0.0;
|
|
}
|
|
if(!point->IsDefined() || !pnt->IsDefined()){
|
|
return std::numeric_limits<double>::max();
|
|
}
|
|
return calcDistanz(point,pnt);
|
|
|
|
}
|
|
|
|
double calcDistanz(Picture* pnt1, Picture* pnt2)
|
|
{
|
|
double distance;
|
|
gta::DistData* dd1 = df.getData(pnt1);
|
|
gta::DistData* dd2 = df.getData(pnt2);
|
|
df.dist(dd1, dd2, distance);
|
|
delete dd1;
|
|
delete dd2;
|
|
return distance;
|
|
}
|
|
|
|
/*
|
|
6.4 ~calcXDistanz~
|
|
|
|
Calculate the distance in the first
|
|
dimension between this and the committed point.
|
|
|
|
*/
|
|
double calcXDistanz(Picture* pnt){
|
|
return calcDistanz(pnt);
|
|
|
|
}
|
|
|
|
int getCntDimensions(){
|
|
return 2;
|
|
}
|
|
|
|
void printPicture(){
|
|
}
|
|
|
|
/*
|
|
6.5 ~getOuterLeftValue~
|
|
|
|
get the mostly left item.
|
|
|
|
*/
|
|
Picture* getOuterLeftValue(Picture* outerPicture, Picture* innerPicture ){
|
|
return getXValOfPic(innerPicture)
|
|
> getXValOfPic(outerPicture) ? innerPicture : outerPicture ;
|
|
}
|
|
|
|
|
|
/*
|
|
6.6 ~getOuterRightValue~
|
|
|
|
get teh mostly right item.
|
|
|
|
*/
|
|
Picture* getOuterRightValue(Picture* outerPicture,
|
|
Picture* outerPictureRighCl, Picture* innerPicture )
|
|
{
|
|
Picture* retPicture = getOuterRightValue( outerPicture, innerPicture ) ;
|
|
return getOuterRightValue(outerPictureRighCl,retPicture) ;
|
|
}
|
|
|
|
Picture* getOuterRightValue(Picture* outerPicture, Picture* innerPicture )
|
|
{
|
|
return getXValOfPic(innerPicture)
|
|
< getXValOfPic(outerPicture) ?
|
|
innerPicture : outerPicture ;
|
|
}
|
|
|
|
/*
|
|
6.7 ~setCoordinates~
|
|
|
|
Set the setCoordinates with the pictrure distance function.
|
|
This is necessary for sorting pictures in first dimension.
|
|
|
|
*/
|
|
void setCoordinates(Picture* _xRef,Picture* _yRef)
|
|
{
|
|
xRef = _xRef;
|
|
xVal = calcDistanz(_xRef,point);
|
|
yVal = calcDistanz(_yRef,point);
|
|
|
|
};
|
|
|
|
void setCoordinates(Picture* _xRef,double _yRef)
|
|
{
|
|
xRef = _xRef;
|
|
xVal = calcDistanz(_xRef,point);
|
|
yVal = _yRef;
|
|
|
|
};
|
|
};
|
|
|
|
|
|
}
|
|
|
|
#endif
|