7604 lines
247 KiB
C++
7604 lines
247 KiB
C++
/*
|
|
|
|
|
|
//[_] [\_]
|
|
//[TOC] [\tableofcontents]
|
|
//[Title] [ \title{ROSEAlgebra} \author{Mirco Guenster, Dirk Ansorge} \maketitle]
|
|
//[times] [\ensuremath{\times}]
|
|
//[->] [\ensuremath{\rightarrow}]
|
|
|
|
|
|
|
|
[1] Rose Algebra
|
|
|
|
[TOC]
|
|
|
|
|
|
January 3rd, 2003 Mirco G[ue]nster and Ismail Zerrad
|
|
|
|
December 2005, Victor Almeida deleted the deprecated algebra levels
|
|
(~executable~, ~descriptive~, and ~hibrid~). Only the executable
|
|
level remains. Models are also removed from type constructors.
|
|
|
|
This algebra implements an interface between the Rose Algebra which was
|
|
implemented in the Java programming language and Secondo.
|
|
This means that this module is an algebra in terms of Secondo but the
|
|
proper functionality is implemented in Java. Therefore most of the
|
|
functions here are wrapper functions which call with help of the
|
|
JNI (Java Native Interface) according java methods.
|
|
This algebra provides three type constructors ~ccpoints~, ~cclines~
|
|
and ~ccregions~ with its operations.
|
|
For more details of the "Rose"-Algebra in common see the paper:
|
|
"Realm-Based Spatial Data Types - The ROSE Algebra"
|
|
by Ralf Hartmut Gueting and Markus Schneider.
|
|
For more details of the JNI (Java Native Interface) see
|
|
"The Java (tm) Native Interface Programmmers Guide and Specification"
|
|
by Sheng Liang. This book is online available as PDF file at www.sun.com.
|
|
|
|
1 Preliminaries
|
|
|
|
1.1 Includes and global declarations
|
|
|
|
*/
|
|
|
|
|
|
#include "Algebra.h"
|
|
#include "Application.h"
|
|
#include "LogMsg.h"
|
|
#include "NestedList.h"
|
|
#include "QueryProcessor.h"
|
|
#include "StandardTypes.h"
|
|
#include "Attribute.h"
|
|
#include "Symbols.h"
|
|
#include "../Rectangle/RectangleAlgebra.h"
|
|
|
|
#include <stack>
|
|
#include <time.h>
|
|
#include <cmath>
|
|
|
|
extern NestedList* nl;
|
|
extern QueryProcessor* qp;
|
|
|
|
#include "Attribute.h"
|
|
#include <jni.h>
|
|
#include <JVMInit.h>
|
|
|
|
using namespace std;
|
|
|
|
/*
|
|
The JVMInitializer provides access to a pointer to
|
|
the JNI Environment and to a pointer to the
|
|
Java Virtual Machine.
|
|
|
|
*/
|
|
static JVMInitializer *jvminit = 0;
|
|
|
|
//Pointers to the JVM Environment and JVM.
|
|
static JNIEnv *env;
|
|
static JavaVM *jvm;
|
|
|
|
//The deviation value.
|
|
static double DEVIATION_VALUE;
|
|
|
|
//Pointers to some 2DSACK classes.
|
|
static jclass clsPoints;
|
|
static jclass clsLines;
|
|
static jclass clsRegions;
|
|
static jclass clsRational;
|
|
static jclass clsPoint;
|
|
static jclass clsPointMultiSet;
|
|
static jclass clsSegment;
|
|
static jclass clsSegMultiSet;
|
|
static jclass clsLinkedList;
|
|
static jclass clsCycleList;
|
|
static jclass clsCycleListListPoints;
|
|
static jclass clsRationalFactory;
|
|
static jclass clsSegmentComparator;
|
|
static jclass clsROSEAlgebra;
|
|
static jclass clsRect;
|
|
|
|
//Pointers to some 2DSACK methods.
|
|
static jmethodID midRationalGetDouble;
|
|
static jmethodID midPMSToArray;
|
|
static jmethodID midSegmentGetStartpoint;
|
|
static jmethodID midSegmentGetEndpoint;
|
|
static jmethodID midSMSToArray;
|
|
static jmethodID midLLToArray;
|
|
static jmethodID midCLToArray;
|
|
static jmethodID midCLLPToArray;
|
|
static jmethodID midRegionsCyclesPoints;
|
|
static jmethodID midRFConstRational;
|
|
static jmethodID midPointConstII;
|
|
static jmethodID midPointConstDD;
|
|
static jmethodID midPointConstRR;
|
|
static jmethodID midPointsConst;
|
|
static jmethodID midPointsAddPoint;
|
|
static jmethodID midSegmentConstIIII;
|
|
static jmethodID midSegmentConstDDDD;
|
|
static jmethodID midSegmentConstRRRR;
|
|
static jmethodID midLinesConst;
|
|
static jmethodID midLinesAddSegment;
|
|
static jmethodID midSCConst;
|
|
static jmethodID midSMSConst;
|
|
static jmethodID midSMSAdd;
|
|
static jmethodID midSegmentConstPP;
|
|
static jmethodID midRegionsConstVoid;
|
|
static jmethodID midRegionsConstSMS;
|
|
static jmethodID midPointsCompare;
|
|
static jmethodID midPointsWriteToByteArray;
|
|
static jmethodID midPointsReadFrom;
|
|
static jmethodID midPointsPrint;
|
|
static jmethodID midPointsRect;
|
|
static jmethodID midLinesCompare;
|
|
static jmethodID midLinesWriteToByteArray;
|
|
static jmethodID midLinesReadFrom;
|
|
static jmethodID midLinesPrint;
|
|
static jmethodID midLinesRect;
|
|
static jmethodID midRegionsCompare;
|
|
static jmethodID midRegionsWriteToByteArray;
|
|
static jmethodID midRegionsReadFrom;
|
|
static jmethodID midRegionsPrint;
|
|
static jmethodID midRationalGetNumerator;
|
|
static jmethodID midRationalGetDenominator;
|
|
static jmethodID midROSESetDeviationValue;
|
|
static jmethodID midROSEChooseTriangulator;
|
|
static jmethodID midRegionsRect;
|
|
static jmethodID midRectGetTopLeftX;
|
|
static jmethodID midRectGetTopLeftY;
|
|
static jmethodID midRectGetBottomRightX;
|
|
static jmethodID midRectGetBottomRightY;
|
|
|
|
//Pointers to field IDs of 2DSACK.
|
|
static jfieldID fidRationalX;
|
|
static jfieldID fidRationalY;
|
|
static jfieldID fidPointsPointSet;
|
|
static jfieldID fidLinesSegmentSet;
|
|
|
|
static jclass clsRoseError;
|
|
static jfieldID fidROSEError;
|
|
|
|
//Pointers to ROSE operations.
|
|
static jmethodID midROSEp_diameter;
|
|
static jmethodID midROSEp_no_of_components;
|
|
|
|
static jmethodID midROSEl_diameter;
|
|
static jmethodID midROSEl_interior;
|
|
static jmethodID midROSEl_length;
|
|
static jmethodID midROSEl_no_of_components;
|
|
static jmethodID midROSEl_vertices;
|
|
|
|
static jmethodID midROSEr_area;
|
|
static jmethodID midROSEr_contour;
|
|
static jmethodID midROSEr_diameter;
|
|
static jmethodID midROSEr_no_of_components;
|
|
static jmethodID midROSEr_perimeter;
|
|
static jmethodID midROSEr_vertices;
|
|
|
|
static jmethodID midROSEpp_disjoint;
|
|
static jmethodID midROSEpp_dist;
|
|
static jmethodID midROSEpp_equal;
|
|
static jmethodID midROSEpp_plus;
|
|
static jmethodID midROSEpp_minus;
|
|
static jmethodID midROSEpp_unequal;
|
|
static jmethodID midROSEpp_intersection;
|
|
|
|
static jmethodID midROSEll_border_in_common;
|
|
static jmethodID midROSEll_common_border;
|
|
static jmethodID midROSEll_disjoint;
|
|
static jmethodID midROSEll_dist;
|
|
static jmethodID midROSEll_equal;
|
|
static jmethodID midROSEll_intersection;
|
|
static jmethodID midROSEll_intersects;
|
|
static jmethodID midROSEll_meets;
|
|
static jmethodID midROSEll_minus;
|
|
static jmethodID midROSEll_plus;
|
|
static jmethodID midROSEll_unequal;
|
|
|
|
static jmethodID midROSErr_adjacent;
|
|
static jmethodID midROSErr_area_disjoint;
|
|
static jmethodID midROSErr_border_in_common;
|
|
static jmethodID midROSErr_common_border;
|
|
static jmethodID midROSErr_disjoint;
|
|
static jmethodID midROSErr_dist;
|
|
static jmethodID midROSErr_edge_disjoint;
|
|
static jmethodID midROSErr_edge_inside;
|
|
static jmethodID midROSErr_encloses;
|
|
static jmethodID midROSErr_equal;
|
|
static jmethodID midROSErr_inside;
|
|
static jmethodID midROSErr_intersection;
|
|
static jmethodID midROSErr_intersects;
|
|
static jmethodID midROSErr_meets;
|
|
static jmethodID midROSErr_minus;
|
|
static jmethodID midROSErr_plus;
|
|
static jmethodID midROSErr_unequal;
|
|
static jmethodID midROSErr_vertex_inside;
|
|
|
|
static jmethodID midROSEpl_dist;
|
|
static jmethodID midROSEpl_on_border_of;
|
|
|
|
static jmethodID midROSEpr_dist;
|
|
static jmethodID midROSEpr_inside;
|
|
static jmethodID midROSEpr_on_border_of;
|
|
|
|
static jmethodID midROSElp_dist;
|
|
|
|
static jmethodID midROSErp_dist;
|
|
|
|
static jmethodID midROSElr_border_in_common;
|
|
static jmethodID midROSElr_common_border;
|
|
static jmethodID midROSElr_dist;
|
|
static jmethodID midROSElr_inside;
|
|
static jmethodID midROSElr_intersects;
|
|
static jmethodID midROSElr_meets;
|
|
|
|
static jmethodID midROSErl_border_in_common;
|
|
static jmethodID midROSErl_common_border;
|
|
static jmethodID midROSErl_dist;
|
|
static jmethodID midROSErl_intersection;
|
|
static jmethodID midROSErl_intersects;
|
|
static jmethodID midROSErl_meets;
|
|
|
|
static const bool DEBUG = false;
|
|
static const bool DEBUG_CONVERT = false;
|
|
|
|
/*
|
|
1.2 Error functions.
|
|
|
|
This error function is called if an error referring to the
|
|
JNI interface occurs. In most cases this indicates that
|
|
there are problems which the installed JDK.
|
|
In this case please check the following items first:
|
|
|
|
a) Under Windows the jvm.dll must be in your PATH.
|
|
b) All paths of used java classes must have an entry in the
|
|
JNIPath.ini file.
|
|
c) Used JAR archives must also have an entry in that file.
|
|
|
|
|
|
*/
|
|
|
|
/*
|
|
this function prints an error message including the line
|
|
where the error occured. Should never invoked normally.
|
|
|
|
*/
|
|
|
|
static void error(const string &name, int line) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
cerr << "Error in " << name << " in line: " << line << "." << endl;
|
|
if(env->ExceptionOccurred())
|
|
env->ExceptionDescribe();
|
|
exit(1);
|
|
}
|
|
|
|
static void RoseError() {
|
|
jthrowable exec = env->ExceptionOccurred();
|
|
env->ExceptionClear();
|
|
const char* errMsgC =
|
|
env->GetStringUTFChars((jstring)env->GetObjectField(exec,fidROSEError),0);
|
|
cmsg.error() << errMsgC << endl;
|
|
cmsg.send();
|
|
}
|
|
|
|
|
|
/*
|
|
this function prints an error message including the line
|
|
where the error occured. This method is used for calls
|
|
to Java methods. The name of the Java method which
|
|
should invoked is also printed.
|
|
|
|
*/
|
|
|
|
/*
|
|
1.4 Conversion Functions
|
|
|
|
These functions convert a C++-Nested List into a Java object and
|
|
vice versa.
|
|
|
|
*/
|
|
|
|
|
|
/*
|
|
The following function takes a java object of type Rational
|
|
and returns a suitable ListExpr
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Rational(jobject jRational) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jdouble value = env->CallDoubleMethod(jRational, midRationalGetDouble);
|
|
|
|
env->DeleteLocalRef(jRational);
|
|
jRational = 0;
|
|
return nl->RealAtom(value);
|
|
}
|
|
|
|
/*
|
|
The following function takes a java object of type Point
|
|
and returns a suitable ListExpr
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Point(jobject jPoint) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jobject X = env->GetObjectField(jPoint, fidRationalX);
|
|
if (X == 0) error(__FILE__,__LINE__);
|
|
|
|
jobject Y = env->GetObjectField(jPoint, fidRationalY);
|
|
if (Y == 0) error(__FILE__,__LINE__);
|
|
|
|
return nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(X),
|
|
nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(Y),
|
|
nl->TheEmptyList()
|
|
)
|
|
);
|
|
}
|
|
|
|
|
|
/*
|
|
The following function takes a java object of type Points
|
|
and returns a suitable ListExpr
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Points(jobject jPoints) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jobject jpointlist = env->GetObjectField(jPoints, fidPointsPointSet);
|
|
if (jpointlist == 0) error(__FILE__,__LINE__);
|
|
|
|
jobjectArray oarr =
|
|
(jobjectArray)env->CallObjectMethod(jpointlist, midPMSToArray);
|
|
if (oarr == 0) error(__FILE__,__LINE__);
|
|
|
|
//Determine the length of the result array.
|
|
int oarrlen = (int)env->GetArrayLength(oarr);
|
|
|
|
//Collect all calculated subnodes in a stack first.
|
|
stack<jobject> jstack;
|
|
for (int i = 0; i < oarrlen; i++) {
|
|
jstack.push(env->GetObjectArrayElement(oarr, i));
|
|
}
|
|
|
|
// Then assemble the result.
|
|
ListExpr result = nl->TheEmptyList();
|
|
while (!jstack.empty()) {
|
|
result = nl->Cons(Convert_JavaToC_Point(jstack.top()),result);
|
|
jobject tmp = jstack.top();
|
|
jstack.pop();
|
|
env->DeleteLocalRef(tmp);
|
|
tmp = 0;
|
|
}
|
|
|
|
env->DeleteLocalRef(jpointlist);
|
|
jpointlist = 0;
|
|
env->DeleteLocalRef(oarr);
|
|
oarr = 0;
|
|
env->DeleteLocalRef(jPoints);
|
|
jPoints = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
The following function takes a java object of type Segment
|
|
and returns a suitable ListExpr
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Segment(jobject jSegment) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Get the start Point itself
|
|
jobject startP = env->CallObjectMethod(jSegment, midSegmentGetStartpoint);
|
|
if (startP == 0) error(__FILE__,__LINE__);
|
|
|
|
// Get the end Point itself
|
|
jobject endP = env->CallObjectMethod(jSegment, midSegmentGetEndpoint);
|
|
if (endP == 0) error(__FILE__,__LINE__);
|
|
|
|
// Get the field x itself (start point)
|
|
//jobject X1 = env->GetObjectField(startP, fidX1);
|
|
jobject X1 = env->GetObjectField(startP, fidRationalX);
|
|
if (X1 == 0) error(__FILE__,__LINE__);
|
|
|
|
// Get the field y itself (start point)
|
|
//jobject Y1 = env->GetObjectField(startP, fidY1);
|
|
jobject Y1 = env->GetObjectField(startP, fidRationalY);
|
|
if (X1 == 0) error(__FILE__,__LINE__);
|
|
|
|
// Get the field x itself (end point)
|
|
//jobject X2 = env->GetObjectField(endP, fidX2);
|
|
jobject X2 = env->GetObjectField(endP, fidRationalX);
|
|
if (X1 == 0) error(__FILE__,__LINE__);
|
|
|
|
// Get the field y itself (end point)
|
|
//jobject Y2 = env->GetObjectField(endP, fidY2);
|
|
jobject Y2 = env->GetObjectField(endP, fidRationalY);
|
|
if (X1 == 0) error(__FILE__,__LINE__);
|
|
|
|
env->DeleteLocalRef(startP);
|
|
startP = 0;
|
|
env->DeleteLocalRef(endP);
|
|
endP = 0;
|
|
|
|
return
|
|
nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(X1),
|
|
nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(Y1),
|
|
nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(X2),
|
|
nl->Cons
|
|
(
|
|
Convert_JavaToC_Rational(Y2),
|
|
nl->TheEmptyList()
|
|
)
|
|
)
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
The following function takes a java object of type Lines
|
|
and returns a suitable ListExpr.
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Lines(jobject jLines) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Get the field itself
|
|
jobject jseglist = env->GetObjectField(jLines, fidLinesSegmentSet);
|
|
if (jseglist == 0) error(__FILE__,__LINE__);
|
|
|
|
// Call the method itself
|
|
jobjectArray oarr =
|
|
(jobjectArray)env->CallObjectMethod(jseglist, midSMSToArray);
|
|
if (oarr == 0) error(__FILE__,__LINE__);
|
|
|
|
// Determine the length of the result array.
|
|
int oarrlen = (int)env->GetArrayLength(oarr);
|
|
|
|
// Collect all calculated subnodes in a stack first.
|
|
stack<jobject> jstack;
|
|
for (int i = 0; i < oarrlen; i++) {
|
|
jstack.push(env->GetObjectArrayElement(oarr, i));
|
|
}
|
|
|
|
// Then assemble the result.
|
|
ListExpr result = nl->TheEmptyList();
|
|
while (!jstack.empty()) {
|
|
result = nl->Cons(Convert_JavaToC_Segment(jstack.top()),result);
|
|
jobject tmp = jstack.top();
|
|
jstack.pop();
|
|
env->DeleteLocalRef(tmp);
|
|
tmp = 0;
|
|
}
|
|
|
|
env->DeleteLocalRef(oarr);
|
|
oarr = 0;
|
|
env->DeleteLocalRef(jseglist);
|
|
jseglist = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
The following function takes a java object of type ElemList
|
|
and returns a suitable ListExpr.
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_ElemList(jobject jpointList) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Call the method itself
|
|
jobjectArray oarr =
|
|
(jobjectArray)env->CallObjectMethod(jpointList, midLLToArray);
|
|
if (oarr == 0) error(__FILE__,__LINE__);
|
|
|
|
// Determine the length of the result array.
|
|
int oarrlen = (int)env->GetArrayLength(oarr);
|
|
|
|
// Collect all calculated subnodes in a stack first.
|
|
stack<jobject> jstack;
|
|
for (int i = 0; i < oarrlen; i++) {
|
|
jstack.push(env->GetObjectArrayElement(oarr, i));
|
|
}
|
|
|
|
//Then assemble the result.
|
|
ListExpr result = nl->TheEmptyList();
|
|
while (!jstack.empty()) {
|
|
result = nl->Cons(Convert_JavaToC_Point(jstack.top()),result);
|
|
jobject tmp = jstack.top();
|
|
jstack.pop();
|
|
env->DeleteLocalRef(tmp);
|
|
tmp = 0;
|
|
}
|
|
|
|
env->DeleteLocalRef(oarr);
|
|
oarr = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
The following function takes a java object of type ElemListList
|
|
and returns a suitable ListExpr.
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_ElemListList(jobject jCycleList) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Call the method itself
|
|
jobjectArray oarr =
|
|
(jobjectArray)env->CallObjectMethod(jCycleList, midCLToArray);
|
|
if (oarr == 0) error(__FILE__,__LINE__);
|
|
|
|
// Determine the length of the result array.
|
|
int oarrlen = (int)env->GetArrayLength(oarr);
|
|
|
|
// Collect all calculated subnodes in a stack first.
|
|
stack<jobject> jstack;
|
|
for (int i = 0; i < oarrlen; i++) {
|
|
jstack.push(env->GetObjectArrayElement(oarr, i));
|
|
}
|
|
|
|
// Then assemble the result.
|
|
ListExpr result = nl->TheEmptyList();
|
|
while (!jstack.empty()) {
|
|
result = nl->Cons(Convert_JavaToC_ElemList(jstack.top()),result);
|
|
jobject tmp = jstack.top();
|
|
jstack.pop();
|
|
env->DeleteLocalRef(tmp);
|
|
tmp = 0;
|
|
}
|
|
|
|
env->DeleteLocalRef(oarr);
|
|
oarr = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
The following function takes a java object of type ElemListListList
|
|
and returns a suitable ListExpr.
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_ElemListListList(jobject jCycleListListPoints) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Call the method itself
|
|
jobjectArray oarr =
|
|
(jobjectArray)env->CallObjectMethod(jCycleListListPoints, midCLLPToArray);
|
|
if (oarr == 0) error(__FILE__,__LINE__);
|
|
|
|
// Determine the length of the result array.
|
|
int oarrlen = (int)env->GetArrayLength(oarr);
|
|
|
|
// Collect all calculated subnodes in a stack first.
|
|
stack<jobject> jstack;
|
|
for (int i = 0; i < oarrlen; i++) {
|
|
jstack.push(env->GetObjectArrayElement(oarr, i));
|
|
}
|
|
|
|
// Then assemble the result.
|
|
ListExpr result = nl->TheEmptyList();
|
|
while (!jstack.empty()) {
|
|
result = nl->Cons(Convert_JavaToC_ElemListList(jstack.top()),result);
|
|
jobject tmp = jstack.top();
|
|
jstack.pop();
|
|
env->DeleteLocalRef(tmp);
|
|
tmp = 0;
|
|
}
|
|
|
|
env->DeleteLocalRef(oarr);
|
|
oarr = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
The following function takes a java object of type Regions
|
|
and returns a suitable ListExpr.
|
|
|
|
*/
|
|
|
|
static ListExpr Convert_JavaToC_Regions(jobject jRegions) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (!jRegions) cerr << "jRegions is NULL!" << endl;
|
|
|
|
// Call the method itself
|
|
jobject cycles = env->CallObjectMethod(jRegions, midRegionsCyclesPoints);
|
|
if (cycles == 0) error(__FILE__,__LINE__);
|
|
|
|
ListExpr res = Convert_JavaToC_ElemListListList(cycles);
|
|
env->DeleteLocalRef(cycles);
|
|
cycles = 0;
|
|
return res;
|
|
}
|
|
|
|
|
|
/*
|
|
The following function takes a ListExpr of an Rational object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
|
|
static jobject Convert_CToJava_Rational(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Check whether six elements are in le.
|
|
if (nl->ListLength(le) != 6) error(__FILE__,__LINE__);
|
|
|
|
// Now we calculate the necessary data for creating a Rational object.
|
|
ListExpr e2 = nl->Second(le);
|
|
ListExpr e3 = nl->Third(le);
|
|
ListExpr e4 = nl->Fourth(le);
|
|
ListExpr e6 = nl->Sixth(le);
|
|
|
|
string value2 = nl->SymbolValue(e2);
|
|
long value3 = nl->IntValue(e3);
|
|
long value4 = nl->IntValue(e4);
|
|
long value6 = nl->IntValue(e6);
|
|
|
|
int Rat_sign = (value2 == "-") ? -1 : 1;
|
|
int Rat_intPart = value3 * Rat_sign;
|
|
int Rat_numDec = value4 * Rat_sign;
|
|
int Rat_dnmDec = value6;
|
|
|
|
jobject result =
|
|
env->CallStaticObjectMethod(clsRationalFactory, midRFConstRational,
|
|
Rat_intPart * Rat_dnmDec + Rat_numDec,
|
|
Rat_dnmDec);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
The following function takes a ListExpr of a Point object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
static jobject Convert_CToJava_Point(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Check whether two elements are in le.
|
|
if (nl->ListLength(le) != 2) error(__FILE__,__LINE__);
|
|
|
|
// Now we calculate the necessary data for creating a Point object.
|
|
ListExpr e1 = nl->First(le);
|
|
ListExpr e2 = nl->Second(le);
|
|
|
|
if (
|
|
(nl->IsAtom(e1)) &&
|
|
(nl->IsAtom(e2)) &&
|
|
(nl->AtomType(e1) == IntType) &&
|
|
(nl->AtomType(e2) == IntType)) {
|
|
// Both coordinates are integers
|
|
int intValue1 = nl->IntValue(e1);
|
|
int intValue2 = nl->IntValue(e2);
|
|
|
|
jobject result =
|
|
env->NewObject(clsPoint, midPointConstII, intValue1, intValue2);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
return result;
|
|
}
|
|
else if
|
|
(
|
|
(nl->IsAtom(e1)) &&
|
|
(nl->IsAtom(e2)) &&
|
|
(nl->AtomType(e1) == RealType) &&
|
|
(nl->AtomType(e2) == RealType)) {
|
|
// Both coordinates are reals
|
|
//jfloat realValue1 = nl->RealValue(e1);
|
|
jdouble realValue1 = nl->RealValue(e1);
|
|
//jfloat realValue2 = nl->RealValue(e2);
|
|
jdouble realValue2 = nl->RealValue(e2);
|
|
|
|
//jobject result = env->NewObject(clsPoint,
|
|
// midPointConstDD,
|
|
// (jfloat)realValue1,
|
|
// (jfloat)realValue2);
|
|
jobject result = env->NewObject(clsPoint,
|
|
midPointConstDD,
|
|
realValue1,
|
|
realValue2);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
return result;
|
|
} else {
|
|
// Both coordinates are Rationals
|
|
//cout << "rationals" << endl;
|
|
jobject num1 = Convert_CToJava_Rational(e1);
|
|
jobject num2 = Convert_CToJava_Rational(e2);
|
|
|
|
jobject result = env->NewObject(clsPoint, midPointConstRR,num1,num2);
|
|
env->DeleteLocalRef(num1);
|
|
num1 = 0;
|
|
env->DeleteLocalRef(num2);
|
|
num2 = 0;
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
The following function takes a ListExpr of a Points object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
static jobject Convert_CToJava_Points(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jobject points = env->NewObject(clsPoints, midPointsConst);
|
|
if (points == 0) error(__FILE__,__LINE__);
|
|
|
|
// Now we detect the length of le.
|
|
int ll = nl->ListLength(le);
|
|
|
|
if (ll == 0) {
|
|
//return empty points value
|
|
return points;
|
|
}
|
|
|
|
bool isPoints = true;
|
|
|
|
ListExpr first = nl->First(le);
|
|
if (nl->IsAtom(first)) isPoints = false;
|
|
else {
|
|
isPoints = nl->ListLength(first) == 2;
|
|
}
|
|
|
|
if (isPoints) {
|
|
// Now we insert in a for-loop all points into the Points object.
|
|
ListExpr restlist = le;
|
|
for (int i = 0; i < ll; i++) {
|
|
ListExpr first = nl->First(restlist);
|
|
restlist = nl->Rest(restlist);
|
|
// create a java object points
|
|
jobject jfirst = Convert_CToJava_Point(first);
|
|
if (jfirst == 0) error(__FILE__,__LINE__);
|
|
env->CallVoidMethod(points, midPointsAddPoint, jfirst);
|
|
env->DeleteLocalRef(jfirst);
|
|
jfirst = 0;
|
|
}
|
|
}
|
|
else {
|
|
jobject jfirst = Convert_CToJava_Point(le);
|
|
if (jfirst == 0) error(__FILE__,__LINE__);
|
|
env->CallVoidMethod(points, midPointsAddPoint, jfirst);
|
|
env->DeleteLocalRef(jfirst);
|
|
jfirst = 0;
|
|
}
|
|
return points;
|
|
}
|
|
|
|
/*
|
|
The following function takes a ListExpr of a Segment object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
|
|
static jobject Convert_CToJava_Segment(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// Check whether four elements are in le.
|
|
if (nl->ListLength(le) != 4) error(__FILE__,__LINE__);
|
|
|
|
// Now we calculate the necessary data for creating a Point object.
|
|
ListExpr e1 = nl->First(le);
|
|
ListExpr e2 = nl->Second(le);
|
|
ListExpr e3 = nl->Third(le);
|
|
ListExpr e4 = nl->Fourth(le);
|
|
|
|
if
|
|
(
|
|
(nl->IsAtom(e1)) &&
|
|
(nl->IsAtom(e2)) &&
|
|
(nl->IsAtom(e3)) &&
|
|
(nl->IsAtom(e4)) &&
|
|
(nl->AtomType(e1) == IntType) &&
|
|
(nl->AtomType(e2) == IntType) &&
|
|
(nl->AtomType(e3) == IntType) &&
|
|
(nl->AtomType(e4) == IntType)) {
|
|
|
|
// All coordinates are integers
|
|
int intValue1 = nl->IntValue(e1);
|
|
int intValue2 = nl->IntValue(e2);
|
|
int intValue3 = nl->IntValue(e3);
|
|
int intValue4 = nl->IntValue(e4);
|
|
|
|
jobject result = env->NewObject(clsSegment, midSegmentConstIIII,
|
|
intValue1, intValue2,
|
|
intValue3, intValue4);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
return result;
|
|
}
|
|
else if
|
|
(
|
|
(nl->IsAtom(e1)) &&
|
|
(nl->IsAtom(e2)) &&
|
|
(nl->IsAtom(e3)) &&
|
|
(nl->IsAtom(e4)) &&
|
|
(nl->AtomType(e1) == RealType) &&
|
|
(nl->AtomType(e2) == RealType) &&
|
|
(nl->AtomType(e3) == RealType) &&
|
|
(nl->AtomType(e4) == RealType)) {
|
|
|
|
// All coordinates are reals
|
|
jdouble realValue1 = nl->RealValue(e1);
|
|
jdouble realValue2 = nl->RealValue(e2);
|
|
jdouble realValue3 = nl->RealValue(e3);
|
|
jdouble realValue4 = nl->RealValue(e4);
|
|
|
|
//jobject result = env->NewObject(clsSegment,
|
|
// midSegmentConstDDDD,
|
|
// (jfloat)realValue1,
|
|
// (jfloat)realValue2,
|
|
// (jfloat)realValue3,
|
|
// (jfloat)realValue4);
|
|
jobject result = env->NewObject(clsSegment,
|
|
midSegmentConstDDDD,
|
|
realValue1,
|
|
realValue2,
|
|
realValue3,
|
|
realValue4);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
return result;
|
|
} else {
|
|
jobject num1 = Convert_CToJava_Rational(e1);
|
|
jobject num2 = Convert_CToJava_Rational(e2);
|
|
jobject num3 = Convert_CToJava_Rational(e3);
|
|
jobject num4 = Convert_CToJava_Rational(e4);
|
|
|
|
jobject result =
|
|
env->NewObject(clsSegment, midSegmentConstRRRR, num1,num2,num3,num4);
|
|
env->DeleteLocalRef(num1);
|
|
num1 = 0;
|
|
env->DeleteLocalRef(num2);
|
|
num2 = 0;
|
|
env->DeleteLocalRef(num3);
|
|
num3 = 0;
|
|
env->DeleteLocalRef(num4);
|
|
num4 = 0;
|
|
|
|
return result;
|
|
}
|
|
}
|
|
|
|
/*
|
|
The following function takes a ListExpr of a Lines object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
|
|
static jobject Convert_CToJava_Lines(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jobject lines = env->NewObject(clsLines, midLinesConst);
|
|
if (lines == 0) error(__FILE__,__LINE__);
|
|
|
|
// Now we detect the length of le.
|
|
int ll = nl->ListLength(le);
|
|
|
|
// Now we insert in a for-loop all points into the Lines object.
|
|
ListExpr restlist = le;
|
|
for (int i = 0; i < ll; i++) {
|
|
ListExpr first = nl->First(restlist);
|
|
restlist = nl->Rest(restlist);
|
|
// create a java object segment
|
|
jobject jfirst = Convert_CToJava_Segment(first);
|
|
if (jfirst == 0) error(__FILE__,__LINE__);
|
|
env->CallVoidMethod(lines, midLinesAddSegment, jfirst);
|
|
env->DeleteLocalRef(jfirst);
|
|
jfirst = 0;
|
|
}
|
|
|
|
return lines;
|
|
}
|
|
|
|
/*
|
|
The following function takes a ListExpr of a Regions object and creates
|
|
the suitable Java object from it.
|
|
|
|
*/
|
|
static jobject Convert_CToJava_Regions(const ListExpr &le) {
|
|
if (DEBUG_CONVERT) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
// We have to collect all segments into a segment list first
|
|
|
|
// Create a new SegmentComparator
|
|
jobject jSC = env->NewObject(clsSegmentComparator, midSCConst);
|
|
if (jSC == 0) error(__FILE__,__LINE__);
|
|
|
|
// Create a SMS object.
|
|
jobject segMS = env->NewObject(clsSegMultiSet, midSMSConst, jSC);
|
|
if (segMS == 0) error(__FILE__,__LINE__);
|
|
|
|
|
|
// Determine how many faces are in le.
|
|
int nllfaces = nl->ListLength(le);
|
|
|
|
// Now we put all segments of the faces into the seglist.
|
|
ListExpr restFaceList = le;
|
|
for (int i = 0; i < nllfaces; i++) {
|
|
ListExpr firstFace = nl->First(restFaceList);
|
|
restFaceList = nl->Rest(restFaceList);
|
|
// Determine how many cycles are in firstFace.
|
|
int nllcycles = nl->ListLength(firstFace);
|
|
|
|
// Now we put all segments of the cycles into the seglist.
|
|
ListExpr restCycleList = firstFace;
|
|
for (int j = 0; j < nllcycles; j++) {
|
|
ListExpr firstCycle = nl->First(restCycleList);
|
|
restCycleList = nl->Rest(restCycleList);
|
|
// Determine how many vertices are in firstCycle.
|
|
int nllvertex = nl->ListLength(firstCycle);
|
|
// Calculate all vertices first.
|
|
jobject vertex[nllvertex];
|
|
ListExpr restVertexList = firstCycle;
|
|
for (int k = 0; k < nllvertex; k++) {
|
|
ListExpr firstVertex = nl->First(restVertexList);
|
|
restVertexList = nl->Rest(restVertexList);
|
|
vertex[k] = Convert_CToJava_Point(firstVertex);
|
|
}
|
|
// Connect the kth and the (k+1)th Point to a segment.
|
|
jobject segment[nllvertex];
|
|
for (int k = 0; k < nllvertex - 1; k++) {
|
|
segment[k] = env->NewObject(clsSegment, midSegmentConstPP,
|
|
vertex[k], vertex[k+1]);
|
|
if (segment[k] == 0) error(__FILE__,__LINE__);
|
|
}
|
|
|
|
segment[nllvertex-1] = env->NewObject(clsSegment, midSegmentConstPP,
|
|
vertex[nllvertex-1], vertex[0]);
|
|
if (segment[nllvertex-1] == 0) error(__FILE__,__LINE__);
|
|
|
|
//clear memory used for vertices
|
|
for (int k = 0; k < nllvertex; k++) {
|
|
env->DeleteLocalRef(vertex[k]);
|
|
vertex[k] = 0;
|
|
}
|
|
|
|
// Now add all segments to the SegMultiSet
|
|
for (int k = 0; k < nllvertex; k++) {
|
|
env->CallVoidMethod(segMS, midSMSAdd, segment[k]);
|
|
}
|
|
|
|
//clear memory used for segments
|
|
for (int k = 0; k < nllvertex-1; k++) {
|
|
env->DeleteLocalRef(segment[k]);
|
|
segment[k] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
jobject result = env->NewObject(clsRegions, midRegionsConstSMS, segMS);
|
|
if (result == 0) error(__FILE__,__LINE__);
|
|
|
|
//free memory used by Java objects
|
|
env->DeleteLocalRef(jSC);
|
|
jSC = 0;
|
|
env->DeleteLocalRef(segMS);
|
|
segMS = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
2 Type Constructor ~Points~
|
|
|
|
2.1 Data Structure - Class ~CcPoints~
|
|
|
|
The class CcPoints is just a wrapper to the
|
|
according Points Java class.
|
|
The cls attribute holds a pointer to the
|
|
Java class Points and the obj attribute
|
|
holds a pointer to the java object itself.
|
|
These pointers are used to invoke according
|
|
java methods.
|
|
|
|
*/
|
|
|
|
class CcPoints: public Attribute {
|
|
private:
|
|
jobject obj;
|
|
Flob objectData;
|
|
bool canDelete;
|
|
void RestoreFLOBFromJavaObject();
|
|
void SyncBboxData();
|
|
|
|
public:
|
|
// Bounding Box data
|
|
double BboxTopLeftX;
|
|
double BboxTopLeftY;
|
|
double BboxBottomRightX;
|
|
double BboxBottomRightY;
|
|
|
|
// Inherited methods of Attribute
|
|
int Compare(const Attribute *attr) const;
|
|
Attribute *Clone() const;
|
|
void CopyFrom(const Attribute* right);
|
|
void Destroy();
|
|
jobject GetObject() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj; }
|
|
bool Adjacent(const Attribute *arg) const;
|
|
int NumOfFLOBs() const;
|
|
Flob *GetFLOB(const int i);
|
|
void Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno);
|
|
void Finalize() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
void RestoreJavaObjectFromFLOB();
|
|
size_t HashValue() const;
|
|
size_t Sizeof() const {
|
|
return sizeof(*this);
|
|
}
|
|
/* This constructor takes the nested list representation
|
|
of CcPoints and recovers the underlying java object with
|
|
help of this data. */
|
|
CcPoints(const ListExpr &le, bool isList);
|
|
// SPM: added an addtional parameter since size_t and ListExpr are ambigous
|
|
// on 64 bit systems.
|
|
|
|
/* This constructor takes a pointer to a java object which is
|
|
already created. */
|
|
CcPoints(const jobject jobj);
|
|
/* This constructor creates an empty CcPoints object. */
|
|
CcPoints();
|
|
CcPoints(size_t size);
|
|
/* retrieves the nested list representation of the underlying
|
|
java object. */
|
|
|
|
void SetObject(jobject obj) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
this->obj = obj;
|
|
}
|
|
|
|
bool GetNL(ListExpr &le);
|
|
/* Destructor of CcPoints. This destructor destroys also the
|
|
object inside the JVM. */
|
|
|
|
~CcPoints() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
/* Returns the pointer to the proper java objet. */
|
|
jobject GetObj() const;
|
|
void Print() const;
|
|
|
|
};
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
int CcPoints::Compare(const Attribute *attr) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcPoints *P = (const CcPoints *) attr;
|
|
return env->CallByteMethod(obj,midPointsCompare,P->obj);
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
Attribute *CcPoints::Clone() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* res = new CcPoints((size_t)objectData.getSize());
|
|
res->CopyFrom(this);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
void CcPoints::CopyFrom(const Attribute* right) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcPoints *P = (const CcPoints *)right;
|
|
objectData.copyFrom(P->objectData);
|
|
BboxTopLeftX = P->BboxTopLeftX;
|
|
BboxTopLeftY = P->BboxTopLeftY;
|
|
BboxBottomRightX = P->BboxBottomRightX;
|
|
BboxBottomRightY = P->BboxBottomRightY;
|
|
obj=0;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
size_t CcPoints::HashValue() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 0;
|
|
}
|
|
|
|
bool CcPoints::Adjacent(const Attribute * arg) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return false;
|
|
}
|
|
|
|
int CcPoints::NumOfFLOBs() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 1;
|
|
}
|
|
|
|
Flob *CcPoints::GetFLOB(const int i){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
assert(i==0);
|
|
return &objectData;
|
|
}
|
|
|
|
void CcPoints::Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = 0;
|
|
SetDefined(true);
|
|
}
|
|
|
|
|
|
/*
|
|
Constructors
|
|
|
|
*/
|
|
|
|
CcPoints::CcPoints(size_t size):Attribute(true),
|
|
objectData(size),canDelete(false)
|
|
{
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
SetDefined(true);
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
if (obj == 0) error(__FILE__,__LINE__);
|
|
}
|
|
|
|
/*
|
|
This constructor takes the nested list representation
|
|
of CcPoints and recovers the underlying java object with
|
|
help of this data.
|
|
|
|
*/
|
|
|
|
CcPoints::CcPoints(const ListExpr &le, bool isList):
|
|
Attribute(true),objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = Convert_CToJava_Points(le);
|
|
canDelete = false;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor takes a pointer to a java object which is
|
|
already created.
|
|
|
|
*/
|
|
|
|
CcPoints::CcPoints(const jobject jobj):Attribute(true),objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete = false;
|
|
obj = jobj;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor creates an empty CcPoints object.
|
|
|
|
*/
|
|
|
|
CcPoints::CcPoints() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
}
|
|
|
|
|
|
/*
|
|
retrieves the nested list representation of the underlying
|
|
java object.
|
|
|
|
*/
|
|
|
|
bool CcPoints::GetNL(ListExpr& le) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (!IsDefined()) {
|
|
le = nl->TheEmptyList();
|
|
return true;
|
|
}
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
assert(obj != 0);
|
|
le = Convert_JavaToC_Points(obj);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Destructor of CcPoints. This destructor destroys also the
|
|
object inside the JVM.
|
|
|
|
*/
|
|
|
|
/*
|
|
~Destroy~
|
|
|
|
The Destroy function as known from other (non-JNI) algebras.
|
|
|
|
*/
|
|
|
|
void CcPoints::Destroy(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete=true;
|
|
}
|
|
|
|
/*
|
|
Returns the pointer to the proper java objet.
|
|
|
|
*/
|
|
|
|
jobject CcPoints::GetObj() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj;
|
|
}
|
|
|
|
|
|
/*
|
|
restores the java object from FLOB
|
|
the FLOB must exists
|
|
|
|
*/
|
|
|
|
void CcPoints::RestoreFLOBFromJavaObject(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jbyteArray jbytes =
|
|
(jbyteArray) env->CallObjectMethod(obj,midPointsWriteToByteArray);
|
|
if(jbytes == 0) error(__FILE__,__LINE__);
|
|
|
|
int size = env->GetArrayLength(jbytes);
|
|
char *bytes = (char*) env->GetByteArrayElements(jbytes,0);
|
|
objectData.resize(size);
|
|
objectData.write(bytes, size ,0);
|
|
env->ReleaseByteArrayElements(jbytes,(jbyte*)bytes,JNI_ABORT);
|
|
env->DeleteLocalRef(jbytes);
|
|
jbytes = 0;
|
|
}
|
|
|
|
|
|
/*
|
|
creates the content of a FLOB from the given Java-Object
|
|
|
|
*/
|
|
|
|
void CcPoints::RestoreJavaObjectFromFLOB(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (obj) return;
|
|
// read the data from flob
|
|
if(&objectData == 0){
|
|
return;
|
|
}
|
|
int size = objectData.getSize();
|
|
char *bytes = objectData.getData();
|
|
// copy the data into a java-array
|
|
jbyteArray jbytes = env->NewByteArray(size);
|
|
env->SetByteArrayRegion(jbytes,0,size,(jbyte*)bytes);
|
|
|
|
obj = env->CallStaticObjectMethod(clsPoints,midPointsReadFrom,jbytes);
|
|
if(obj == 0){
|
|
error(__FILE__,__LINE__);
|
|
}
|
|
//obj = jres;
|
|
jbyte* elems = env->GetByteArrayElements(jbytes,0);
|
|
env->ReleaseByteArrayElements(jbytes,elems,JNI_ABORT);
|
|
bytes = NULL;
|
|
env->DeleteLocalRef(jbytes);
|
|
delete[] bytes;
|
|
}
|
|
|
|
|
|
void CcPoints::Print() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//jmethodID mid = env->GetMethodID(clsPoints,"print","()V");
|
|
env->CallVoidMethod(obj,midPointsPrint);
|
|
}
|
|
|
|
|
|
void CcPoints::SyncBboxData() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//restore object if not present
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
//get bounding box of the Java Points object
|
|
jobject bbox = env->CallObjectMethod(obj,midPointsRect);
|
|
if (bbox == 0) error(__FILE__,__LINE__);
|
|
|
|
//get the coordinates of the bounding box
|
|
BboxTopLeftX = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftX);
|
|
BboxTopLeftY = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftY);
|
|
BboxBottomRightX = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightX);
|
|
BboxBottomRightY = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightY);
|
|
}
|
|
|
|
|
|
/*
|
|
2.2 List Representation
|
|
|
|
The list representation of a CcPoints object is
|
|
|
|
---- (point1 point2 ... pointn)
|
|
----
|
|
|
|
whereas the (internal) list representation of a point is
|
|
|
|
---- (xCoord yCoord)
|
|
----
|
|
|
|
whereas the (internal) list representation of a coordinate is
|
|
|
|
---- (rat <sign> <intPart> <numDecimal> / <denomDecimal>)
|
|
----
|
|
|
|
|
|
|
|
|
|
2.3 ~In~ and ~Out~ Functions for CcPoints
|
|
|
|
*/
|
|
|
|
static ListExpr OutCcPoints( ListExpr typeInfo, Word value ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccpoints = (CcPoints*)(value.addr);
|
|
ListExpr le;
|
|
|
|
if (ccpoints->GetNL(le) == false) error(__FILE__, __LINE__);
|
|
return le;
|
|
}
|
|
|
|
|
|
static Word InCcPoints(const ListExpr typeInfo,
|
|
const ListExpr instance,
|
|
const int errorPos,
|
|
ListExpr& errorInfo,
|
|
bool& correct ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* newpoints;
|
|
|
|
correct = true;
|
|
newpoints = new CcPoints(instance);
|
|
|
|
return SetWord(newpoints);
|
|
}
|
|
|
|
/*
|
|
Creation of a CcPoints object.
|
|
|
|
*/
|
|
static Word CreateCcPoints(const ListExpr typeInfo) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* res = new CcPoints((size_t)1);
|
|
res->SetObject(0);
|
|
return SetWord(res);
|
|
}
|
|
|
|
/*
|
|
Deletion of a CcPoints object.
|
|
|
|
*/
|
|
|
|
static void DeleteCcPoints(const ListExpr typeInfo, Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Delete of CcPointss +++" << endl;
|
|
//((CcPoints*)w.addr)->Finalize();
|
|
delete ((CcPoints *)w.addr);
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Close a CcPoints object.
|
|
|
|
*/
|
|
|
|
static void CloseCcPoints(const ListExpr typeInfo, Word & w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Close of CcPoints +++" << endl;
|
|
delete (CcPoints *)w.addr;
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Clone a CcPoints object.
|
|
|
|
*/
|
|
|
|
static Word CloneCcPoints(const ListExpr typeInfo, const Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return SetWord(((CcPoints *)w.addr)->Clone());
|
|
}
|
|
|
|
static void* CastCcPoints( void* addr ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return new (addr) CcPoints;
|
|
}
|
|
|
|
bool OpenCcPoints(SmiRecord& valueRecord,
|
|
size_t& offset,
|
|
const ListExpr typeInfo,
|
|
Word& value){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* P = (CcPoints*)Attribute::Open(valueRecord,offset, typeInfo);
|
|
//P->RestoreJavaObjectFromFLOB();
|
|
P->SetObject(0);
|
|
value = SetWord(P);
|
|
return true;
|
|
}
|
|
|
|
bool SaveCcPoints( SmiRecord& valueRecord,
|
|
size_t& offset,
|
|
const ListExpr typeInfo,
|
|
Word& value) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* P = (CcPoints*) value.addr;
|
|
Attribute::Save(valueRecord,offset,typeInfo,P);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
2.4 Function Describing the Signature of the Type Constructor
|
|
|
|
*/
|
|
|
|
static ListExpr PointsProperty() {
|
|
|
|
return
|
|
(nl->TwoElemList
|
|
(
|
|
nl->FiveElemList
|
|
(nl->StringAtom("Signature"),
|
|
nl->StringAtom("Example Type List"),
|
|
nl->StringAtom("List Rep"),
|
|
nl->StringAtom("Example List"),
|
|
nl->StringAtom("Remarks")),
|
|
nl->FiveElemList
|
|
(nl->StringAtom("-> DATA"),
|
|
nl->StringAtom("rpoints"),
|
|
nl->StringAtom("(<p1> <p2> ... <pN>)"),
|
|
nl->StringAtom("..."),
|
|
nl->StringAtom("a set of points "))));
|
|
}
|
|
|
|
/*
|
|
2.5 Kind Checking Function
|
|
|
|
This function checks whether the type constructor is applied correctly. Since
|
|
type constructor ~ccpoints~ does not have arguments, this is trivial.
|
|
|
|
*/
|
|
|
|
static bool CheckCcPoints( ListExpr type, ListExpr& errorInfo ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
bool res = (nl->IsEqual(type, "rpoints"));
|
|
return res;
|
|
}
|
|
|
|
|
|
int
|
|
SizeOfCcPoints()
|
|
{
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return sizeof(CcPoints);
|
|
}
|
|
|
|
/*
|
|
2.6 Creation of the Type Constructor Instance
|
|
|
|
*/
|
|
|
|
TypeConstructor ccpoints
|
|
(
|
|
"rpoints",
|
|
// name
|
|
PointsProperty,
|
|
// property function describing the signature
|
|
OutCcPoints,
|
|
// out function
|
|
InCcPoints,
|
|
// in function
|
|
0, 0,
|
|
//SaveToList and RestoreFromList functions
|
|
CreateCcPoints,
|
|
// object creation
|
|
DeleteCcPoints,
|
|
// object deletion
|
|
OpenCcPoints,
|
|
// object open
|
|
SaveCcPoints,
|
|
// object save
|
|
CloseCcPoints,
|
|
// object close
|
|
CloneCcPoints,
|
|
// object clone
|
|
CastCcPoints,
|
|
// cast function
|
|
SizeOfCcPoints,
|
|
//sizeof function
|
|
CheckCcPoints
|
|
// kind checking function
|
|
);
|
|
|
|
|
|
/*
|
|
3 Type Constructor ~Lines~
|
|
|
|
3.1 Data Structure - Class ~Lines~
|
|
|
|
The class CcLines is just a wrapper to the
|
|
according Lines Java class.
|
|
The cls attribute holds a pointer to the
|
|
Java class Lines and the obj attribute
|
|
holds a pointer to the java object itself.
|
|
These pointers are used to invoke according
|
|
java methods.
|
|
|
|
*/
|
|
|
|
class CcLines: public Attribute {
|
|
private:
|
|
jobject obj;
|
|
Flob objectData;
|
|
bool canDelete;
|
|
void RestoreFLOBFromJavaObject();
|
|
void SyncBboxData();
|
|
|
|
public:
|
|
// Bounding Box data
|
|
double BboxTopLeftX;
|
|
double BboxTopLeftY;
|
|
double BboxBottomRightX;
|
|
double BboxBottomRightY;
|
|
|
|
// Inherited methods of Attribute
|
|
int Compare(const Attribute *attr) const;
|
|
Attribute *Clone() const;
|
|
void CopyFrom(const Attribute* right);
|
|
void Destroy();
|
|
jobject GetObject() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj; }
|
|
bool Adjacent(const Attribute *arg) const;
|
|
int NumOfFLOBs() const;
|
|
Flob *GetFLOB(const int i);
|
|
void Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno);
|
|
void Finalize() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
void RestoreJavaObjectFromFLOB();
|
|
size_t HashValue() const;
|
|
size_t Sizeof() const {
|
|
return sizeof(*this);
|
|
}
|
|
|
|
/* This constructor takes the nested list representation
|
|
of CcLines and recovers the underlying java object with
|
|
help of this data. */
|
|
CcLines(const ListExpr &le, bool isList);
|
|
/* This constructor takes a pointer to a java object which is
|
|
already created. */
|
|
CcLines(const jobject jobj);
|
|
/* retrieves the nested list representation of the underlying
|
|
java object. */
|
|
/* This constructor creates an empty CcLines object. */
|
|
CcLines();
|
|
CcLines(size_t size);
|
|
bool GetNL(ListExpr &le);
|
|
|
|
void SetObject(jobject obj) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
this->obj = obj;
|
|
}
|
|
|
|
/* Destructor of CcLines. This destructor destroys also the
|
|
object inside the JVM. */
|
|
~CcLines() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
/* Returns the pointer to the proper java objet. */
|
|
jobject GetObj() const;
|
|
|
|
void Print() const;
|
|
};
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
int CcLines::Compare(const Attribute *attr) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcLines *L = (const CcLines *) attr;
|
|
return env->CallByteMethod(obj,midLinesCompare,L->obj);
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
Attribute *CcLines::Clone() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* res = new CcLines((size_t)objectData.getSize());
|
|
res->CopyFrom(this);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
void CcLines::CopyFrom(const Attribute* right) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcLines *L = (const CcLines *)right;
|
|
objectData.copyFrom(L->objectData);
|
|
BboxTopLeftX = L->BboxTopLeftX;
|
|
BboxTopLeftY = L->BboxTopLeftY;
|
|
BboxBottomRightX = L->BboxBottomRightX;
|
|
BboxBottomRightY = L->BboxBottomRightY;
|
|
obj=0;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
size_t CcLines::HashValue() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 0;
|
|
}
|
|
|
|
bool CcLines::Adjacent(const Attribute * arg) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return false;
|
|
}
|
|
|
|
int CcLines::NumOfFLOBs() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 1;
|
|
}
|
|
|
|
Flob *CcLines::GetFLOB(const int i) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
assert(i==0);
|
|
return &objectData;
|
|
}
|
|
|
|
void CcLines::Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = 0;
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
Constructors
|
|
|
|
*/
|
|
|
|
CcLines::CcLines(size_t size):Attribute(true),
|
|
objectData(size),canDelete(false) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
SetDefined(true);
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
if (obj == 0) error(__FILE__,__LINE__);
|
|
}
|
|
|
|
/*
|
|
This constructor takes the nested list representation
|
|
of CcLines and recovers the underlying java object with
|
|
help of this data.
|
|
|
|
*/
|
|
|
|
CcLines::CcLines(const ListExpr &le, bool isList): Attribute(true),
|
|
objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = Convert_CToJava_Lines(le);
|
|
canDelete = false;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor takes a pointer to a java object which is
|
|
already created.
|
|
|
|
*/
|
|
|
|
CcLines::CcLines(const jobject jobj) : Attribute(true),objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete = false;
|
|
obj = jobj;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor creates an empty CcPoints object.
|
|
|
|
*/
|
|
|
|
CcLines::CcLines() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
}
|
|
|
|
/*
|
|
retrieves the nested list representation of the underlying
|
|
java object.
|
|
|
|
*/
|
|
|
|
bool CcLines::GetNL(ListExpr& le) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (!IsDefined()) {
|
|
le = nl->TheEmptyList();
|
|
return true;
|
|
}
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
le = Convert_JavaToC_Lines(obj);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Destructor of CcLines. This destructor destroys also the
|
|
object inside the JVM.
|
|
|
|
*/
|
|
|
|
/*
|
|
~Destroy~
|
|
|
|
The Destroy function as known from other (non-JNI) algebras.
|
|
|
|
*/
|
|
|
|
void CcLines::Destroy(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete=true;
|
|
}
|
|
|
|
/*
|
|
Returns the pointer to the proper java objet.
|
|
|
|
*/
|
|
|
|
jobject CcLines::GetObj() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj;
|
|
}
|
|
|
|
/*
|
|
restores the java object from FLOB
|
|
the FLOB must exist
|
|
|
|
*/
|
|
|
|
void CcLines::RestoreFLOBFromJavaObject(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jbyteArray jbytes =
|
|
(jbyteArray) env->CallObjectMethod(obj,midLinesWriteToByteArray);
|
|
if(jbytes == 0) error(__FILE__,__LINE__);
|
|
|
|
int size = env->GetArrayLength(jbytes);
|
|
|
|
char *bytes = (char*) env->GetByteArrayElements(jbytes,0);
|
|
objectData.resize(size);
|
|
objectData.write(bytes, size,0);
|
|
env->ReleaseByteArrayElements(jbytes,(jbyte*)bytes,JNI_ABORT);
|
|
env->DeleteLocalRef(jbytes);
|
|
jbytes = 0;
|
|
}
|
|
|
|
/*
|
|
creates the content of a FLOB from the given Java-Object
|
|
|
|
*/
|
|
|
|
void CcLines::RestoreJavaObjectFromFLOB(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (obj) return;
|
|
|
|
if(&objectData == 0){
|
|
return;
|
|
}
|
|
int size = objectData.getSize();
|
|
|
|
char *bytes = objectData.getData();
|
|
// copy the data into a java-array
|
|
jbyteArray jbytes = env->NewByteArray(size);
|
|
env->SetByteArrayRegion(jbytes,0,size,(jbyte*)bytes);
|
|
|
|
obj = env->CallStaticObjectMethod(clsLines,midLinesReadFrom,jbytes);
|
|
if(obj == 0) error(__FILE__,__LINE__);
|
|
|
|
//obj = jres;
|
|
jbyte* elems = env->GetByteArrayElements(jbytes,0);
|
|
env->ReleaseByteArrayElements(jbytes,elems,JNI_ABORT);
|
|
env->DeleteLocalRef(jbytes);
|
|
jbytes = 0;
|
|
delete[] bytes;
|
|
}
|
|
|
|
|
|
void CcLines::Print() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//jmethodID mid = env->GetMethodID(clsLines,"print","()V");
|
|
env->CallVoidMethod(obj,midLinesPrint);
|
|
}
|
|
|
|
void CcLines::SyncBboxData() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//restore object if not present
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
//get bounding box of the Java Lines object
|
|
jobject bbox = env->CallObjectMethod(obj,midLinesRect);
|
|
if (bbox == 0) error(__FILE__,__LINE__);
|
|
|
|
//get the coordinates of the bounding box
|
|
BboxTopLeftX = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftX);
|
|
BboxTopLeftY = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftY);
|
|
BboxBottomRightX = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightX);
|
|
BboxBottomRightY = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightY);
|
|
}
|
|
|
|
|
|
/*
|
|
3.2 List Representation
|
|
|
|
The list representation of a CcLines object is
|
|
|
|
---- (segment1 segment2 ... segmentn)
|
|
----
|
|
|
|
whereas the (internal) list representation of a segment is
|
|
|
|
---- (x1 y1 x2 y2)
|
|
----
|
|
|
|
whereas x1, y1, x2 and y2 are (internal) list representations
|
|
of rational numbers
|
|
|
|
---- (x1 y1 x2 y2)
|
|
----
|
|
|
|
whereas the (internal) list representation of a rational number is
|
|
|
|
---- (rat <sign> <intPart> <numDecimal> / <denomDecimal>)
|
|
----
|
|
|
|
|
|
3.3 ~In~ and ~Out~ Functions for CcLines
|
|
|
|
*/
|
|
|
|
static ListExpr OutCcLines( ListExpr typeInfo, Word value ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* cclines = (CcLines*)(value.addr);
|
|
ListExpr le;
|
|
|
|
if (cclines->GetNL(le) == false) error(__FILE__, __LINE__);
|
|
return le;
|
|
}
|
|
|
|
static Word InCcLines(const ListExpr typeInfo,
|
|
const ListExpr instance,
|
|
const int errorPos,
|
|
ListExpr& errorInfo,
|
|
bool& correct ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* newlines;
|
|
|
|
correct = true;
|
|
newlines = new CcLines(instance);
|
|
|
|
return SetWord(newlines);
|
|
}
|
|
|
|
/*
|
|
Creation of a CcLines object.
|
|
|
|
*/
|
|
|
|
static Word CreateCcLines(const ListExpr typeInfo) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "CreateCcLines" << endl;
|
|
|
|
CcLines* res = new CcLines((size_t)1);
|
|
res->SetObject(0);
|
|
return SetWord(res);
|
|
}
|
|
|
|
/*
|
|
Deletion of a CcLines object.
|
|
|
|
*/
|
|
static void DeleteCcLines(const ListExpr typeInfo, Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Delete of CcLines +++" << endl;
|
|
//((CcLines*)w.addr)->Finalize();
|
|
delete ((CcLines *)w.addr);
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Close a CcLines object.
|
|
|
|
*/
|
|
static void CloseCcLines(const ListExpr typeInfo, Word & w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Close of CcLines +++" << endl;
|
|
delete (CcLines *)w.addr;
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Clone a CcLines object.
|
|
|
|
*/
|
|
|
|
static Word CloneCcLines(const ListExpr typeInfo, const Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return SetWord(((CcLines *)w.addr)->Clone());
|
|
}
|
|
|
|
static void* CastCcLines( void* addr ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return new (addr) CcLines;
|
|
}
|
|
|
|
bool OpenCcLines(SmiRecord& valueRecord,
|
|
size_t& offset,
|
|
const ListExpr typeInfo,
|
|
Word& value) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* L = (CcLines*) Attribute::Open(valueRecord,offset, typeInfo);
|
|
//L->RestoreJavaObjectFromFLOB();
|
|
L->SetObject(0);
|
|
value = SetWord(L);
|
|
return true;
|
|
}
|
|
|
|
bool SaveCcLines( SmiRecord& valueRecord ,
|
|
size_t& offset,
|
|
const ListExpr typeInfo,
|
|
Word& value){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* L = (CcLines*) value.addr;
|
|
Attribute::Save(valueRecord,offset,typeInfo,L);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
3.4 Function Describing the Signature of the Type Constructor
|
|
|
|
*/
|
|
|
|
static ListExpr LinesProperty() {
|
|
|
|
return
|
|
(nl->TwoElemList
|
|
(
|
|
nl->FiveElemList
|
|
(nl->StringAtom("Signature"),
|
|
nl->StringAtom("Example Type List"),
|
|
nl->StringAtom("List Rep"),
|
|
nl->StringAtom("Example List"),
|
|
nl->StringAtom("Remarks")),
|
|
nl->FiveElemList
|
|
(nl->StringAtom("-> DATA"),
|
|
nl->StringAtom("rline"),
|
|
nl->StringAtom("(<seg1> <seg2> ... <segN>)"),
|
|
nl->StringAtom("..."),
|
|
nl->StringAtom("missing."))));
|
|
}
|
|
|
|
/*
|
|
3.5 Kind Checking Function
|
|
|
|
This function checks whether the type constructor is applied correctly. Since
|
|
type constructor ~cclines~ does not have arguments, this is trivial.
|
|
|
|
*/
|
|
|
|
static bool CheckCcLines(ListExpr type, ListExpr& errorInfo ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return (nl->IsEqual(type, "rline"));
|
|
}
|
|
|
|
int
|
|
SizeOfCcLines()
|
|
{
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return sizeof(CcLines);
|
|
}
|
|
|
|
|
|
/*
|
|
3.6 Creation of the Type Constructor Instance
|
|
|
|
*/
|
|
|
|
TypeConstructor cclines (
|
|
"rline",
|
|
// name
|
|
LinesProperty,
|
|
// property function describing the signature
|
|
OutCcLines,
|
|
// out function
|
|
InCcLines,
|
|
// in function
|
|
0, 0,
|
|
//SaveToList and RestoreFromList functions
|
|
CreateCcLines,
|
|
// object creation
|
|
DeleteCcLines,
|
|
// object deletion
|
|
OpenCcLines,
|
|
// object open
|
|
SaveCcLines,
|
|
// object save
|
|
CloseCcLines,
|
|
// object close
|
|
CloneCcLines,
|
|
// object clone
|
|
CastCcLines,
|
|
// cast function
|
|
SizeOfCcLines,
|
|
//sizeof function
|
|
CheckCcLines
|
|
// kind checking function
|
|
);
|
|
|
|
/*
|
|
4 Type Constructor ~Regions~
|
|
|
|
4.1 Data Structure - Class ~Regions~
|
|
|
|
The class CcRegions is just a wrapper to the
|
|
according Regions Java class.
|
|
The cls attribute holds a pointer to the
|
|
Java class Lines and the obj attribute
|
|
holds a pointer to the java object itself.
|
|
These pointers are used to invoke according
|
|
java methods.
|
|
|
|
*/
|
|
|
|
class CcRegions: public Attribute {
|
|
private:
|
|
jobject obj;
|
|
Flob objectData;
|
|
bool canDelete;
|
|
void RestoreFLOBFromJavaObject();
|
|
void SyncBboxData();
|
|
|
|
public:
|
|
// Bounding Box data
|
|
double BboxTopLeftX;
|
|
double BboxTopLeftY;
|
|
double BboxBottomRightX;
|
|
double BboxBottomRightY;
|
|
|
|
// Inherited methods of Attribute
|
|
int Compare(const Attribute *attr) const;
|
|
Attribute *Clone() const;
|
|
void CopyFrom(const Attribute* right);
|
|
void Destroy();
|
|
jobject GetObject() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj; }
|
|
bool Adjacent(const Attribute *arg) const;
|
|
int NumOfFLOBs() const;
|
|
Flob *GetFLOB(const int i);
|
|
void Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno);
|
|
void Finalize() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
void RestoreJavaObjectFromFLOB();
|
|
size_t HashValue() const;
|
|
size_t Sizeof() const {
|
|
return sizeof(*this);
|
|
}
|
|
|
|
/* This constructor takes the nested list representation
|
|
of CcRegions and recovers the underlying java object with
|
|
help of this data. */
|
|
CcRegions(const ListExpr &le, bool isList);
|
|
/* This constructor takes a pointer to a java object which is
|
|
already created. */
|
|
CcRegions(const jobject jobj);
|
|
/* This constructor creates an empty CcRegions object. */
|
|
CcRegions();
|
|
CcRegions(size_t size);
|
|
/* retrieves the nested list representation of the underlying
|
|
java object. */
|
|
bool GetNL(ListExpr &le);
|
|
|
|
void SetObject(jobject obj) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
this->obj = obj;
|
|
}
|
|
|
|
/* Destructor of CcRegions. This destructor destroys also the
|
|
object inside the JVM. */
|
|
~CcRegions() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called destructor of CcRegions +++" << endl;
|
|
env->DeleteLocalRef(obj);
|
|
obj = 0;
|
|
}
|
|
// Returns the pointer to the proper java objet.
|
|
jobject GetObj() const;
|
|
void Print() const;
|
|
};
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
int CcRegions::Compare(const Attribute *attr) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcRegions *R = (const CcRegions *) attr;
|
|
return env->CallByteMethod(obj,midRegionsCompare,R->obj);
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
Attribute *CcRegions::Clone() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* res = new CcRegions((size_t)objectData.getSize());
|
|
res->CopyFrom(this);
|
|
return res;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
void CcRegions::CopyFrom(const Attribute* right) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
const CcRegions *R = (const CcRegions *)right;
|
|
objectData.copyFrom(R->objectData);
|
|
BboxTopLeftX = R->BboxTopLeftX;
|
|
BboxTopLeftY = R->BboxTopLeftY;
|
|
BboxBottomRightX = R->BboxBottomRightX;
|
|
BboxBottomRightY = R->BboxBottomRightY;
|
|
obj=0;
|
|
}
|
|
|
|
/*
|
|
Inherited method of Attribute
|
|
|
|
*/
|
|
|
|
size_t CcRegions::HashValue() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 0;
|
|
}
|
|
|
|
bool CcRegions::Adjacent(const Attribute * arg) const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return false;
|
|
}
|
|
|
|
int CcRegions::NumOfFLOBs() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 1;
|
|
}
|
|
|
|
Flob *CcRegions::GetFLOB(const int i){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
assert(i==0);
|
|
return &objectData;
|
|
}
|
|
|
|
void CcRegions::Initialize(SmiFileId fileId,
|
|
TupleId tupleId, int attrno) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = 0;
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
Constructors
|
|
|
|
*/
|
|
|
|
CcRegions::CcRegions(size_t size):Attribute(true),
|
|
objectData(size),canDelete(false) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
SetDefined(true);
|
|
obj = env->NewObject(clsRegions, midRegionsConstVoid);
|
|
if (obj == 0) error(__FILE__,__LINE__);
|
|
}
|
|
|
|
/*
|
|
This constructor takes the nested list representation
|
|
of CcRegions and recovers the underlying java object with
|
|
help of this data.
|
|
|
|
*/
|
|
|
|
CcRegions::CcRegions(const ListExpr &le, bool isList):Attribute(true),
|
|
objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
obj = Convert_CToJava_Regions(le);
|
|
canDelete = false;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor takes a pointer to a java object which is
|
|
already created.
|
|
|
|
*/
|
|
|
|
CcRegions::CcRegions(const jobject jobj):Attribute(true),objectData(1) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete = false;
|
|
obj = jobj;
|
|
SyncBboxData();
|
|
RestoreFLOBFromJavaObject();
|
|
SetDefined(true);
|
|
}
|
|
|
|
/*
|
|
This constructor creates an empty CcRegions object.
|
|
|
|
*/
|
|
|
|
CcRegions::CcRegions() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
}
|
|
|
|
/*
|
|
retrieves the nested list representation of the underlying
|
|
java object.
|
|
|
|
*/
|
|
|
|
bool CcRegions::GetNL(ListExpr& le) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (!IsDefined()) {
|
|
le = nl->TheEmptyList();
|
|
return true;
|
|
}
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
le = Convert_JavaToC_Regions(obj);
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
Destructor of CcRegions. This destructor destroys also the
|
|
object inside the JVM.
|
|
|
|
*/
|
|
|
|
/*
|
|
~Destroy~
|
|
|
|
The Destroy function as kinown from other (non-JNI) algebras.
|
|
|
|
*/
|
|
|
|
void CcRegions::Destroy(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
canDelete=true;
|
|
}
|
|
|
|
/*
|
|
Returns the pointer to the proper java object.
|
|
|
|
*/
|
|
|
|
jobject CcRegions::GetObj() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return obj;
|
|
}
|
|
|
|
/*
|
|
restores the java object from FLOB
|
|
the FLOB must exists
|
|
|
|
*/
|
|
|
|
void CcRegions::RestoreFLOBFromJavaObject(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
jbyteArray jbytes =
|
|
(jbyteArray) env->CallObjectMethod(obj,midRegionsWriteToByteArray);
|
|
if(jbytes == 0) error(__FILE__,__LINE__);
|
|
|
|
int size = env->GetArrayLength(jbytes);
|
|
char *bytes = (char*) env->GetByteArrayElements(jbytes,0);
|
|
objectData.resize(size);
|
|
objectData.write(bytes,size,0);
|
|
env->ReleaseByteArrayElements(jbytes,(jbyte*)bytes,JNI_ABORT);
|
|
env->DeleteLocalRef(jbytes);
|
|
jbytes = 0;
|
|
}
|
|
|
|
/*
|
|
creates the content of a FLOB from the given Java-Object
|
|
|
|
*/
|
|
|
|
void CcRegions::RestoreJavaObjectFromFLOB(){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
if (obj) return;
|
|
// read the data from flob
|
|
|
|
if(&objectData == 0){
|
|
return;
|
|
}
|
|
int size = objectData.getSize();
|
|
char *bytes = objectData.getData();
|
|
// copy the data into a java-array
|
|
jbyteArray jbytes = env->NewByteArray(size);
|
|
env->SetByteArrayRegion(jbytes,0,size,(jbyte*)bytes);
|
|
|
|
obj = env->CallStaticObjectMethod(clsRegions,midRegionsReadFrom,jbytes);
|
|
if(obj == 0){
|
|
error(__FILE__,__LINE__);
|
|
}
|
|
//obj = jres;
|
|
jbyte* elems = env->GetByteArrayElements(jbytes,0);
|
|
env->ReleaseByteArrayElements(jbytes,elems,JNI_ABORT);
|
|
env->DeleteLocalRef(jbytes);
|
|
jbytes = 0;
|
|
delete[] bytes;
|
|
}
|
|
|
|
void CcRegions::Print() const {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//jmethodID mid = env->GetMethodID(clsRegions,"print","()V");
|
|
env->CallVoidMethod(obj,midRegionsPrint);
|
|
}
|
|
|
|
void CcRegions::SyncBboxData() {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//restore object if not present
|
|
if (!obj) RestoreJavaObjectFromFLOB();
|
|
//get bounding box of the Java Regions object
|
|
jobject bbox = env->CallObjectMethod(obj,midRegionsRect);
|
|
if (bbox == 0) error(__FILE__,__LINE__);
|
|
|
|
//jmethodID mid = env->GetMethodID(clsRect,"print","()V");
|
|
//if (mid == 0) error (__FILE__,__LINE__);
|
|
//env->CallVoidMethod(bbox,mid);
|
|
|
|
//get the coordinates of the bounding box
|
|
BboxTopLeftX = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftX);
|
|
BboxTopLeftY = (double)env->CallDoubleMethod(bbox,midRectGetTopLeftY);
|
|
BboxBottomRightX = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightX);
|
|
BboxBottomRightY = (double)env->CallDoubleMethod(bbox,midRectGetBottomRightY);
|
|
}
|
|
|
|
/*
|
|
4.2 List Representation
|
|
|
|
The list representation of a CcRegions object is
|
|
|
|
---- (face1 face2 ... facen)
|
|
----
|
|
|
|
whereas the (internal) list representation of a face is
|
|
|
|
---- (outer[_]cycle hole[_]cycle1 hole[_]cycle2 ... hole[_]cyclem)
|
|
----
|
|
|
|
whereas the (internal) list representation of a cycle
|
|
(outer[_]cycle or hole[_]cycle) is
|
|
|
|
---- (vertex1 vertex2 ... vertexk)
|
|
----
|
|
|
|
whereas the (internal) list representation of a vertex is
|
|
the same as for a point:
|
|
|
|
---- (xCoord yCoord)
|
|
----
|
|
|
|
whereas the (internal) list representation of a coordinate is
|
|
|
|
---- (rat <sign> <intPart> <numDecimal> / <denomDecimal>)
|
|
----
|
|
|
|
|
|
4.3 ~In~ and ~Out~ Functions for CcRegions
|
|
|
|
*/
|
|
|
|
static ListExpr OutCcRegions( ListExpr typeInfo, Word value ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccregions = (CcRegions*)(value.addr);
|
|
ListExpr le;
|
|
|
|
if (ccregions->GetNL(le) == false) error(__FILE__, __LINE__);
|
|
|
|
return le;
|
|
}
|
|
|
|
|
|
static Word InCcRegions(const ListExpr typeInfo,
|
|
const ListExpr instance,
|
|
const int errorPos,
|
|
ListExpr& errorInfo,
|
|
bool& correct ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* newregions;
|
|
correct = true;
|
|
newregions = new CcRegions(instance);
|
|
|
|
return SetWord(newregions);
|
|
}
|
|
|
|
/*
|
|
Creation of a CcRegions object.
|
|
|
|
*/
|
|
|
|
static Word CreateCcRegions(const ListExpr typeInfo) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* res = new CcRegions((size_t)1);
|
|
res->SetObject(0);
|
|
return SetWord(res);
|
|
}
|
|
|
|
/*
|
|
Deletion of a CcRegions object.
|
|
|
|
*/
|
|
|
|
static void DeleteCcRegions(const ListExpr typeInfo, Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Delete of CcRegions +++" << endl;
|
|
//((CcRegions*)w.addr)->Finalize();
|
|
delete ((CcRegions *)w.addr);
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Close a CcRegions object.
|
|
|
|
*/
|
|
|
|
static void CloseCcRegions(const ListExpr typeInfo, Word & w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "+++ called Close of CcRegions +++" << endl;
|
|
delete (CcRegions *)w.addr;
|
|
w.addr = 0;
|
|
}
|
|
|
|
/*
|
|
Clone a CcRegions object.
|
|
|
|
*/
|
|
|
|
static Word CloneCcRegions(const ListExpr typeInfo, const Word &w) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return SetWord(((CcRegions *)w.addr)->Clone());
|
|
}
|
|
|
|
static void* CastCcRegions( void* addr ){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return new (addr) CcRegions;
|
|
}
|
|
|
|
bool OpenCcRegions(SmiRecord& valueRecord,size_t& offset,
|
|
const ListExpr typeInfo,Word& value){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* R = (CcRegions*) Attribute::Open(valueRecord,offset, typeInfo);
|
|
R->SetObject(0);
|
|
value = SetWord(R);
|
|
return true;
|
|
}
|
|
|
|
bool SaveCcRegions(SmiRecord& valueRecord,size_t& offset,
|
|
const ListExpr typeInfo,Word& value) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* R = (CcRegions*) value.addr;
|
|
Attribute::Save(valueRecord,offset,typeInfo,R);
|
|
return true;
|
|
}
|
|
|
|
|
|
/*
|
|
4.4 Function Describing the Signature of the Type Constructor
|
|
|
|
*/
|
|
|
|
static ListExpr RegionsProperty() {
|
|
|
|
return
|
|
(nl->TwoElemList
|
|
(
|
|
nl->FiveElemList
|
|
(nl->StringAtom("Signature"),
|
|
nl->StringAtom("Example Type List"),
|
|
nl->StringAtom("List Rep"),
|
|
nl->StringAtom("Example List"),
|
|
nl->StringAtom("Remarks")),
|
|
nl->FiveElemList
|
|
(nl->StringAtom("-> DATA"),
|
|
nl->StringAtom("rregion"),
|
|
nl->StringAtom("(<outer_cycle> <hole_cycle1>... <hole cycleN>)"),
|
|
nl->StringAtom("..."),
|
|
nl->StringAtom("missing."))));
|
|
}
|
|
|
|
|
|
/*
|
|
4.5 Kind Checking Function
|
|
|
|
This function checks whether the type constructor is applied correctly. Since
|
|
type constructor ~cclines~ does not have arguments, this is trivial.
|
|
|
|
*/
|
|
|
|
static bool CheckCcRegions(ListExpr type, ListExpr& errorInfo ) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return (nl->IsEqual(type, "rregion"));
|
|
}
|
|
|
|
int
|
|
SizeOfCcRegions()
|
|
{
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return sizeof(CcRegions);
|
|
}
|
|
|
|
|
|
/*
|
|
4.6 Creation of the Type Constructor Instance
|
|
|
|
*/
|
|
|
|
TypeConstructor ccregions (
|
|
"rregion",
|
|
// name
|
|
RegionsProperty,
|
|
// property function describing the signature
|
|
OutCcRegions,
|
|
// out function
|
|
InCcRegions,
|
|
// in function
|
|
0, 0,
|
|
//SaveToList and RestoreFromList functions
|
|
CreateCcRegions,
|
|
// object creation
|
|
DeleteCcRegions,
|
|
// object deletion
|
|
OpenCcRegions,
|
|
// object open
|
|
SaveCcRegions,
|
|
// object save
|
|
CloseCcRegions,
|
|
// object close
|
|
CloneCcRegions,
|
|
// object clone
|
|
CastCcRegions,
|
|
// cast function
|
|
SizeOfCcRegions,
|
|
//sizeof function
|
|
CheckCcRegions
|
|
// kind checking function
|
|
);
|
|
|
|
/*
|
|
5 Creating Operators
|
|
|
|
5.1 Type Mapping Function
|
|
|
|
Checks whether the correct argument types are supplied for an operator; if so,
|
|
returns a list expression for the result type, otherwise the symbol
|
|
~typeerror~.
|
|
|
|
*/
|
|
|
|
static ListExpr equalTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr unequalTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr disjointTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got "
|
|
"wrong types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr insideTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr intersectsTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr meetsTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr borderInCommonTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr onBorderOfTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr intersectionTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom("rregion");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rline");
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr plusTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rline");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom("rregion");
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr minusTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rline");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom("rregion");
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr commonBorderTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rline");
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom("rline");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom("rline");
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom("rline");
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr verticesTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return nl->SymbolAtom("rpoints");
|
|
if ((nl->AtomType(arg1) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameter of type "
|
|
+nl->SymbolValue(arg1));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"type as parameter.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 1.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr noOfComponentsTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rpoints"))
|
|
return nl->SymbolAtom(CcInt::BasicType());
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return nl->SymbolAtom(CcInt::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return nl->SymbolAtom(CcInt::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) )
|
|
ErrorReporter::ReportError("Type mapping function got parameter of type "
|
|
+nl->SymbolValue(arg1));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"type as parameter.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 1.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr distTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1,arg2;
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rpoints"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType) &&
|
|
(nl->AtomType(arg2) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameters of type "
|
|
+nl->SymbolValue(arg1)+" and "+nl->SymbolValue(arg2));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"types as parameters.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 2.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
static ListExpr diameterTypeMap (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rpoints"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return nl->SymbolAtom(CcReal::BasicType());
|
|
if ((nl->AtomType(arg1) == SymbolType))
|
|
ErrorReporter::ReportError("Type mapping function got parameter of type "
|
|
+nl->SymbolValue(arg1));
|
|
else
|
|
ErrorReporter::ReportError("Type mapping function got wrong "
|
|
"type as parameter.");
|
|
}
|
|
ErrorReporter::ReportError("Type mapping function got a "
|
|
"parameter of lengh != 1.");
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
/*
|
|
This is a general type mapping function for all Rose methods
|
|
which take two parameters.
|
|
|
|
*/
|
|
static ListExpr typeMappingRose (ListExpr args, const char *type1,
|
|
const char *type2,
|
|
const char *resulttype) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1, arg2;
|
|
|
|
if (nl->ListLength(args) == 2) {
|
|
arg1 = nl->First(args);
|
|
arg2 = nl->Second(args);
|
|
if ( nl->IsEqual(arg1, type1)
|
|
&& nl->IsEqual(arg2, type2))
|
|
return nl->SymbolAtom(resulttype);
|
|
}
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
/*
|
|
This is a general type mapping function for all Rose methods
|
|
which take one parameter.
|
|
|
|
*/
|
|
|
|
static ListExpr typeMappingRose (ListExpr args, const char *type1,
|
|
const char *resulttype) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if ( nl->IsEqual(arg1, type1))
|
|
return nl->SymbolAtom(resulttype);
|
|
}
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
|
|
/*
|
|
type mapping function: ccregions x ccregions -> bool
|
|
|
|
*/
|
|
|
|
static ListExpr ccregionsccregionsBool(ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return typeMappingRose(args, "rregion", "rregion", "bool");
|
|
}
|
|
|
|
|
|
/*
|
|
type mapping function: cclines -> ccregions
|
|
|
|
*/
|
|
|
|
static ListExpr cclinesccregions(ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return typeMappingRose(args, "rline", "rregion");
|
|
}
|
|
|
|
|
|
/*
|
|
type mapping function: ccregions -> cclines
|
|
|
|
*/
|
|
|
|
static ListExpr ccregionscclines(ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return typeMappingRose(args, "rregion", "rline");
|
|
}
|
|
|
|
|
|
/*
|
|
type mapping function: ccregions -> real
|
|
|
|
*/
|
|
|
|
static ListExpr ccregionsDouble(ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return typeMappingRose(args, "rregion", CcReal::BasicType().c_str());
|
|
}
|
|
|
|
/*
|
|
type mapping function: cclines -> real
|
|
|
|
*/
|
|
|
|
static ListExpr cclinesDouble(ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return typeMappingRose(args, "rline", CcReal::BasicType().c_str());
|
|
}
|
|
|
|
/*
|
|
type mapping function: int -> bool
|
|
|
|
*/
|
|
|
|
static ListExpr intBool (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1, CcInt::BasicType()))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
}
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
/*
|
|
type mapping function: double -> bool
|
|
|
|
*/
|
|
|
|
static ListExpr doubleBool (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1;
|
|
if (nl->ListLength(args) == 1) {
|
|
arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1, CcReal::BasicType()))
|
|
return nl->SymbolAtom(CcBool::BasicType());
|
|
}
|
|
return nl->SymbolAtom("typeerror");
|
|
}
|
|
|
|
/*
|
|
5.2 Selection Function
|
|
|
|
Is used to select one of several evaluation functions for an overloaded
|
|
operator, based on the types of the arguments. In case of a non-overloaded
|
|
operator, we just have to return 0.
|
|
|
|
*/
|
|
|
|
static int simpleSelect (ListExpr args ){
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
return 0;
|
|
}
|
|
|
|
static int equalSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int unequalSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int disjointSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int insideSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int intersectsSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 3;
|
|
return -1;
|
|
}
|
|
|
|
static int meetsSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 3;
|
|
return -1;
|
|
}
|
|
|
|
static int borderInCommonSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 3;
|
|
return -1;
|
|
}
|
|
|
|
static int onBorderOfSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
return -1;
|
|
}
|
|
|
|
static int intersectionSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 3;
|
|
return -1;
|
|
}
|
|
|
|
static int plusSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int minusSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int commonBorderSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 3;
|
|
return -1;
|
|
}
|
|
|
|
static int verticesSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return 1;
|
|
return -1;
|
|
}
|
|
|
|
static int noOfComponentsSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
static int distSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
ListExpr arg2 = nl->Second(args);
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rpoints") && nl->IsEqual(arg2,"rregion"))
|
|
return 2;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rpoints"))
|
|
return 3;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rline"))
|
|
return 4;
|
|
if (nl->IsEqual(arg1,"rline") && nl->IsEqual(arg2,"rregion"))
|
|
return 5;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rpoints"))
|
|
return 6;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rline"))
|
|
return 7;
|
|
if (nl->IsEqual(arg1,"rregion") && nl->IsEqual(arg2,"rregion"))
|
|
return 8;
|
|
return -1;
|
|
}
|
|
|
|
static int diameterSelect (ListExpr args) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
ListExpr arg1 = nl->First(args);
|
|
if (nl->IsEqual(arg1,"rpoints"))
|
|
return 0;
|
|
if (nl->IsEqual(arg1,"rline"))
|
|
return 1;
|
|
if (nl->IsEqual(arg1,"rregion"))
|
|
return 2;
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
This method gets a Java object, which has to be a Rational instance, and returns a double value.
|
|
|
|
*/
|
|
|
|
static double convertRational(jobject jrat) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
int numerator = env->CallIntMethod(jrat,midRationalGetNumerator);
|
|
int denominator = env->CallIntMethod(jrat,midRationalGetDenominator);
|
|
|
|
return (double)numerator/(double)denominator;
|
|
}
|
|
|
|
|
|
/*
|
|
Call the setDeviationValue Java function.
|
|
|
|
*/
|
|
|
|
static int callSetDeviationValue(CcReal *ccr) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//set deviation value to ccr
|
|
//jmethodID midSetDeviation =
|
|
// env->GetStaticMethodID(clsROSEAlgebra, "setDeviationValue", "(D)V");
|
|
//if (midSetDeviation == 0) error(__FILE__,__LINE__);
|
|
double v = ccr->GetRealval();
|
|
DEVIATION_VALUE = v;
|
|
env->CallStaticVoidMethod(clsROSEAlgebra, midROSESetDeviationValue, v);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Call the chooseTriangulator Java function
|
|
|
|
*/
|
|
|
|
static int callChooseTriangulator(CcInt *cci) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//set the triangulator
|
|
//jmethodID midChooseTri =
|
|
// env->GetStaticMethodID(clsROSEAlgebra, "chooseTriangulator", "(I)V");
|
|
//if (midChooseTri == 0) error(__FILE__,__LINE__);
|
|
env->CallStaticVoidMethod(clsROSEAlgebra,
|
|
midROSEChooseTriangulator,
|
|
cci->GetIntval());
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
5.3.2 The proper Value Mapping Functions.
|
|
|
|
*/
|
|
|
|
/*
|
|
Function to compute bounding box intersection. It returns true, if the bounding boxes intersect. This function
|
|
takes the DEVIATION VALUE into account.
|
|
|
|
*/
|
|
|
|
static bool bboxesIntersect(double o1tlx, double o1tly,
|
|
double o1brx, double o1bry,
|
|
double o2tlx, double o2tly,
|
|
double o2brx, double o2bry) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//cout << "bboxesIntersect" << endl;
|
|
bool xcomm = false;
|
|
bool ycomm = false;
|
|
|
|
// if (o1tlx == o2tlx || o1brx == o2brx ||
|
|
// o1tlx == o2brx || o1brx == o2tlx ||
|
|
// (o1tlx < o2tlx && o1brx > o2tlx) ||
|
|
// (o1tlx < o2brx && o1brx > o2brx) ||
|
|
// (o2tlx < o1tlx && o2brx > o1tlx) ||
|
|
// (o2tlx < o1brx && o2brx > o1brx))
|
|
// xcomm = true;
|
|
|
|
|
|
if (fabs(o1tlx - o2tlx) < DEVIATION_VALUE ||
|
|
fabs(o1brx - o2brx) < DEVIATION_VALUE ||
|
|
fabs(o1tlx - o2brx) < DEVIATION_VALUE ||
|
|
fabs(o1brx - o2tlx) < DEVIATION_VALUE ||
|
|
(o1tlx < o2tlx && o1brx > o2tlx) ||
|
|
(o1tlx < o2brx && o1brx > o2brx) ||
|
|
(o2tlx < o1tlx && o2brx > o1tlx) ||
|
|
(o2tlx < o1brx && o2brx > o1brx))
|
|
xcomm = true;
|
|
|
|
|
|
// if (o1tly == o2tly || o1bry == o2bry ||
|
|
// o1tly == o2bry || o1bry == o1tly ||
|
|
// (o1tly > o2tly && o1bry < o2tly) ||
|
|
// (o1tly > o2bry && o1bry < o2bry) ||
|
|
// (o2tly > o1tly && o2bry < o1tly) ||
|
|
// (o2tly > o1bry && o2bry < o1bry))
|
|
// ycomm = true;
|
|
|
|
|
|
if (abs(o1tly - o2tly) < DEVIATION_VALUE ||
|
|
abs(o1bry - o2bry) < DEVIATION_VALUE ||
|
|
abs(o1tly - o2bry) < DEVIATION_VALUE ||
|
|
abs(o1bry - o2tly) < DEVIATION_VALUE ||
|
|
(o1tly > o2tly && o1bry < o2tly) ||
|
|
(o1tly > o2bry && o1bry < o2bry) ||
|
|
(o2tly > o1tly && o2bry < o1tly) ||
|
|
(o2tly > o1bry && o2bry < o1bry))
|
|
ycomm = true;
|
|
if (xcomm && ycomm)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Function to compute bounding box equality. It returns true, if the bounding boxes are equal. This function
|
|
takes the DEVIATION VALUE into account.
|
|
|
|
*/
|
|
|
|
static bool bboxesEqual(double o1tlx, double o1tly,
|
|
double o1brx, double o1bry,
|
|
double o2tlx, double o2tly,
|
|
double o2brx, double o2bry) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
//if (o1tlx == o2tlx && o1tly == o2tly &&
|
|
// o1brx == o2brx && o1bry == o2bry)
|
|
if (abs(o1tlx - o2tlx) < DEVIATION_VALUE &&
|
|
abs(o1tly - o2tly) < DEVIATION_VALUE &&
|
|
abs(o1brx - o2brx) < DEVIATION_VALUE &&
|
|
abs(o1bry - o2bry) < DEVIATION_VALUE)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
Equals predicate for two ccpoints.
|
|
|
|
*/
|
|
|
|
static int pp_equalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccp1 = ((CcPoints *)args[0].addr);
|
|
CcPoints* ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return false
|
|
if (!bboxesEqual(ccp1->BboxTopLeftX,ccp1->BboxTopLeftY,
|
|
ccp1->BboxBottomRightX,ccp1->BboxBottomRightY,
|
|
ccp2->BboxTopLeftX,ccp2->BboxTopLeftY,
|
|
ccp2->BboxBottomRightX,ccp2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}//if
|
|
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//((CcBool *)result.addr)->Set(true, callJMethod_PPB("pp_equal", ccp1, ccp2));
|
|
jboolean obj = env->CallStaticBooleanMethod(clsROSEAlgebra,midROSEpp_equal,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = false;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_equal,
|
|
// ccp1->GetObj(),ccp2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Equals predicate for two cclines.
|
|
|
|
*/
|
|
|
|
static int ll_equalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ls1 = ((CcLines *)args[0].addr);
|
|
CcLines* ls2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return false
|
|
if (!bboxesEqual(ls1->BboxTopLeftX,ls1->BboxTopLeftY,
|
|
ls1->BboxBottomRightX,ls1->BboxBottomRightY,
|
|
ls2->BboxTopLeftX,ls2->BboxTopLeftY,
|
|
ls2->BboxBottomRightX,ls2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}//if
|
|
|
|
if (!ls1->GetObject()) ls1->RestoreJavaObjectFromFLOB();
|
|
if (!ls2->GetObject()) ls2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//((CcBool *)result.addr)->Set(true, callJMethod_LLB("ll_equal", ls1, ls2));
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_equal,
|
|
ls1->GetObj(),ls2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_equal,
|
|
// ls1->GetObj(),ls2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Equal predicate for two ccregions.
|
|
|
|
*/
|
|
|
|
static int rr_equalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* rs1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* rs2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return false
|
|
if (!bboxesEqual(rs1->BboxTopLeftX,rs1->BboxTopLeftY,
|
|
rs1->BboxBottomRightX,rs1->BboxBottomRightY,
|
|
rs2->BboxTopLeftX,rs2->BboxTopLeftY,
|
|
rs2->BboxBottomRightX,rs2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}//if
|
|
|
|
//bboxes intersect, so prepare to invoke the Java method
|
|
if (!rs1->GetObject()) rs1->RestoreJavaObjectFromFLOB();
|
|
if (!rs2->GetObject()) rs2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//((CcBool *)result.addr)->Set(true, callJMethod_RRB("rr_equal", rs1, rs2));
|
|
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_equal,
|
|
rs1->GetObj(),rs2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_equal,
|
|
// rs1->GetObj(),rs2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]unequal predicate for two ccpoints.
|
|
|
|
*/
|
|
|
|
static int pp_unequalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccps1 = ((CcPoints *)args[0].addr);
|
|
CcPoints* ccps2 = ((CcPoints *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return true
|
|
if (!bboxesEqual(ccps1->BboxTopLeftX,ccps1->BboxTopLeftY,
|
|
ccps1->BboxBottomRightX,ccps1->BboxBottomRightY,
|
|
ccps2->BboxTopLeftX,ccps2->BboxTopLeftY,
|
|
ccps2->BboxBottomRightX,ccps2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
//bboxes are equal, so prepare to invoke Java method
|
|
if (!ccps1->GetObject()) ccps1->RestoreJavaObjectFromFLOB();
|
|
if (!ccps2->GetObject()) ccps2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_unequal,
|
|
ccps1->GetObj(),ccps2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_unequal,
|
|
// ccps1->GetObj(),ccps2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]nequal predicate for two cclines.
|
|
|
|
*/
|
|
|
|
static int ll_unequalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return true
|
|
if (!bboxesEqual(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
|
|
//bboxes are equal, prepare to invoke the Java method
|
|
if (!ccl1 ->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2 ->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_unequal,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_unequal,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
|
|
rr[_]unequal predicate for two ccregions
|
|
|
|
*/
|
|
|
|
static int rr_unequalFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes aren't equal, return true
|
|
if (!bboxesEqual(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
|
|
//bboxes are equal, so prepare to invoke the Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_unequal,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_unequal,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]disjoint predicate for two CcPoints
|
|
|
|
*/
|
|
|
|
static int pp_disjointFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccp1 = ((CcPoints *)args[0].addr);
|
|
CcPoints* ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccp1->BboxTopLeftX,ccp1->BboxTopLeftY,
|
|
ccp1->BboxBottomRightX,ccp1->BboxBottomRightY,
|
|
ccp2->BboxTopLeftX,ccp2->BboxTopLeftY,
|
|
ccp2->BboxBottomRightX,ccp2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
|
|
//bboxes are equal, prepare to invoke the Java method
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_disjoint,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_disjoint,
|
|
// ccp1->GetObj(),ccp2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]disjoint predicate for two CcLines
|
|
|
|
*/
|
|
|
|
static int ll_disjointFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
|
|
//bboxes intersect, so prepare to invoke the Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_disjoint,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_disjoint,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]disjoint predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_disjointFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_disjoint,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_disjoint,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pr[_]inside predicate for CcPoints and CcRegions
|
|
|
|
*/
|
|
|
|
static int pr_insideFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccp = ((CcPoints *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccp->BboxTopLeftX,ccp->BboxTopLeftY,
|
|
ccp->BboxBottomRightX,ccp->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpr_inside,
|
|
ccp->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpr_inside,
|
|
// ccp->GetObj(),ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]inside predicate for CcLines and CcRegions
|
|
|
|
*/
|
|
|
|
static int lr_insideFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_inside,
|
|
ccl->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_inside,
|
|
// ccl->GetObj(),ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]inside predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_insideFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_inside,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_inside,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]area[_]disjoint predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_area_disjointFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return true
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_area_disjoint,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_area_disjoint,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]edge[_]disjoint predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_edge_disjointFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return true
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,true);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_edge_disjoint,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_edge_disjoint,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]edge[_]inside predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_edge_insideFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_edge_inside,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_edge_inside,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]vertex[_]inside predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_vertex_insideFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_vertex_inside,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_vertex_inside,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]intersects predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_intersectsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_intersects,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_intersects,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]meets predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_meetsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_meets,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_meets,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]border[_]in[_]common predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_border_in_commonFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_border_in_common,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_border_in_common,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]adjacent predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_adjacentFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_adjacent,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_adjacent,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]encloses predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_enclosesFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_encloses,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_encloses,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]intersection predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_intersectionFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccresult;
|
|
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
//((CcRegions*)result.addr) =
|
|
// new CcRegions(env->NewObject(clsRegions,midRegionsConstVoid));
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcRegions*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcRegions(env->NewObject(clsRegions,midRegionsConstVoid))));
|
|
ccresult = new CcRegions(env->NewObject(clsRegions,midRegionsConstVoid));
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
return 0;
|
|
}
|
|
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcRegions*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_intersection,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRegions,midRegionsConstVoid);
|
|
}
|
|
ccresult = new CcRegions(obj);
|
|
//ccresult =
|
|
// new CcRegions(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_intersection,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//ccresult = callJMethod_RRR("rr_intersection", ccr1, ccr2);
|
|
//if(env->ExceptionOccurred())
|
|
// env->ExceptionDescribe();
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]plus predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_plusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccresult;
|
|
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcRegions*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_plus,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRegions,midRegionsConstVoid);
|
|
}
|
|
ccresult = new CcRegions(obj);
|
|
//ccresult =
|
|
// new CcRegions(env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_plus,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//ccresult = callJMethod_RRR("rr_plus", ccr1, ccr2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]minus predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_minusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccresult;
|
|
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return first object
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcRegions*)result.addr;
|
|
//((CcRegions*)result.addr) = ccr1;
|
|
//qp->ResultStorage(s,SetWord(ccr1));
|
|
((CcRegions*)result.addr)->CopyFrom(ccr1);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcRegions*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_minus,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRegions,midRegionsConstVoid);
|
|
}
|
|
ccresult = new CcRegions(obj);
|
|
//ccresult =
|
|
// new CcRegions(env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_minus,
|
|
// ccr1->GetObj(),ccr2->GetObj()));
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//jobject res = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_minus,
|
|
// ccr1->GetObj(),ccr2->GetObj());
|
|
//if (res == 0) error(__FILE__, __LINE__);
|
|
//ccresult = new CcRegions(res);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]common[_]border predicate for two CcRegions
|
|
|
|
*/
|
|
|
|
static int rr_common_borderFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcRegions* ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions* ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccr1->BboxTopLeftX,ccr1->BboxTopLeftY,
|
|
ccr1->BboxBottomRightX,ccr1->BboxBottomRightY,
|
|
ccr2->BboxTopLeftX,ccr2->BboxTopLeftY,
|
|
ccr2->BboxBottomRightX,ccr2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
ccresult = new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//delete (CcLines*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst))));
|
|
//((CcRegions*)result.addr) =
|
|
// new CcRegions(env->NewObject(clsRegions,midRegionsConstVoid));
|
|
return 0;
|
|
}
|
|
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErr_common_border,
|
|
ccr1->GetObj(),
|
|
ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_common_border,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj()));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_RRL("rr_common_border", ccr1, ccr2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]intersects predicate for two CcLines
|
|
|
|
*/
|
|
|
|
static int ll_intersectsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to call Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_intersects,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_intersects,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]intersects predicate for CcLines and CcRegions
|
|
|
|
*/
|
|
|
|
static int lr_intersectsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_intersects,
|
|
ccl->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_intersects,
|
|
// ccl->GetObj(),ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]intersects predicate for CcRegions and CcLines
|
|
|
|
*/
|
|
|
|
static int rl_intersectsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErl_intersects,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErl_intersects,
|
|
// ccr->GetObj(),ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]meets predicate for two cclines.
|
|
|
|
*/
|
|
|
|
static int ll_meetsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_meets,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_meets,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]meets predicate for cclines and ccregions.
|
|
|
|
*/
|
|
|
|
static int lr_meetsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_meets,
|
|
ccl->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_meets,
|
|
// ccl->GetObj(),ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]meets predicate for ccregions and cclines
|
|
|
|
*/
|
|
|
|
static int rl_meetsFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErl_meets,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,midROSErl_meets,
|
|
// ccr->GetObj(),ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]border[_]in[_]common predicate for two CcLines.
|
|
|
|
*/
|
|
|
|
static int ll_border_in_commonFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersects, so prepare to invoke Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEll_border_in_common,
|
|
ccl1->GetObj(),
|
|
ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEll_border_in_common,
|
|
// ccl1->GetObj(),
|
|
// ccl2->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]border[_]in[_]common predicate for CcLines and CcRegions.
|
|
|
|
*/
|
|
|
|
static int lr_border_in_commonFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSElr_border_in_common,
|
|
ccl->GetObj(),
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSElr_border_in_common,
|
|
// ccl->GetObj(),
|
|
// ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]border[_]in[_]common predicate for CcRegions and CcLines.
|
|
|
|
*/
|
|
|
|
static int rl_border_in_commonFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErl_border_in_common,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErl_border_in_common,
|
|
// ccr->GetObj(),ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
pl[_]on[_]border[_]of predicate for CcPoints and CcLines
|
|
|
|
*/
|
|
|
|
static int pl_on_border_ofFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccp = ((CcPoints *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccp->BboxTopLeftX,ccp->BboxTopLeftY,
|
|
ccp->BboxBottomRightX,ccp->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEpl_on_border_of,
|
|
ccp->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEpl_on_border_of,
|
|
// ccp->GetObj(),ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pr[_]on[_]border[_]of predicate for CcPoints and CcRegions
|
|
|
|
*/
|
|
|
|
static int pr_on_border_ofFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints* ccp = ((CcPoints *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return false
|
|
if (!bboxesIntersect(ccp->BboxTopLeftX,ccp->BboxTopLeftY,
|
|
ccp->BboxBottomRightX,ccp->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcBool*)result.addr)->Set(true,false);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEpr_on_border_of,
|
|
ccp->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = 0;
|
|
}
|
|
((CcBool*)result.addr)->Set(true,obj);
|
|
//((CcBool*)result.addr)->
|
|
// Set(true,env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEpr_on_border_of,
|
|
// ccp->GetObj(),ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]intersection predicate for two CcPoints.
|
|
|
|
*/
|
|
|
|
static int pp_intersectionFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccresult;
|
|
|
|
CcPoints* ccp1 = ((CcPoints *)args[0].addr);
|
|
CcPoints* ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccp1->BboxTopLeftX,ccp1->BboxTopLeftY,
|
|
ccp1->BboxBottomRightX,ccp1->BboxBottomRightY,
|
|
ccp2->BboxTopLeftX,ccp2->BboxTopLeftY,
|
|
ccp2->BboxBottomRightX,ccp2->BboxBottomRightY)) {
|
|
cout << "intersction: don't intersect" << endl;
|
|
result = qp->ResultStorage(s);
|
|
ccresult = new CcPoints(env->NewObject(clsPoints,midPointsConst));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//delete (CcPoints*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcPoints(env->NewObject(clsPoints,midPointsConst))));
|
|
return 0;
|
|
}
|
|
cout << "intersection: intersect" << endl;
|
|
//bboxes intersect, prepare to invoke Java method
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEpp_intersection,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEpp_intersection,
|
|
// ccp1->GetObj(),ccp2->GetObj()));
|
|
//qp->ResultStorage(s, SetWord(ccresult));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]intersection predicate for two CcLines.
|
|
|
|
*/
|
|
|
|
static int ll_intersectionFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccresult;
|
|
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
ccresult = new CcPoints(env->NewObject(clsPoints,midPointsConst));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcPoints(env->NewObject(clsPoints,midPointsConst))));
|
|
//((CcPoints*)result.addr) =
|
|
// new CcPoints(env->NewObject(clsPoints,midRegionsConstVoid));
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEll_intersection,
|
|
ccl1->GetObj(),
|
|
ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEll_intersection,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_LLP("ll_intersection", ccl1, ccl2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]intersection predicate for CcRegions and CcLines
|
|
|
|
*/
|
|
|
|
static int rl_intersectionFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
//((CcLines*)result.addr) =
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst))));
|
|
ccresult = new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErl_intersection,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//result =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErl_intersection,
|
|
// ccr->GetObj(),ccl->GetObj()));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//ccresult = callJMethod_RLL("rl_intersection", ccr, ccl);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]plus predicate for two CcPoints.
|
|
|
|
*/
|
|
|
|
static int pp_plusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccresult;
|
|
|
|
CcPoints* ccp1 = ((CcPoints *)args[0].addr);
|
|
CcPoints* ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_plus,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_plus,
|
|
// ccp1->GetObj(),ccp2->GetObj()));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
|
|
//ccresult = callJMethod_PPP("pp_plus", ccp1, ccp2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]plus predicate for two CcLines.
|
|
|
|
*/
|
|
|
|
static int ll_plusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_plus,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_plus,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
|
|
//result.addr = ccresult;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]minus predicate for two CcPoints.
|
|
|
|
*/
|
|
|
|
static int pp_minusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp1;
|
|
CcPoints *ccp2;
|
|
CcPoints *ccresult;
|
|
|
|
ccp1 = ((CcPoints *)args[0].addr);
|
|
ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return first object
|
|
if (!bboxesIntersect(ccp1->BboxTopLeftX,ccp1->BboxTopLeftY,
|
|
ccp1->BboxBottomRightX,ccp1->BboxBottomRightY,
|
|
ccp2->BboxTopLeftX,ccp2->BboxTopLeftY,
|
|
ccp2->BboxBottomRightX,ccp2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
((CcPoints*)result.addr)->CopyFrom(ccp1);
|
|
//delete (CcPoints*)result.addr;
|
|
//((CcPoints*)result.addr) = ccp1;
|
|
//qp->ResultStorage(s,SetWord(ccp1));
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_minus,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpp_minus,
|
|
// ccp1->GetObj(),ccp2->GetObj()));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//ccresult = callJMethod_PPP("pp_minus", ccp1, ccp2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]minus predicate for two CcPoints.
|
|
|
|
*/
|
|
|
|
static int ll_minusFun(Word* args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return first object
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
//((CcLines*)result.addr) = ccl1;
|
|
//qp->ResultStorage(s,SetWord(ccl1));
|
|
((CcPoints*)result.addr)->CopyFrom(ccl1);
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_minus,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_minus,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_LLL("ll_minus", ccl1, ccl2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]common[_]border predicate for two CcLines.
|
|
|
|
*/
|
|
|
|
static int ll_common_borderFun(Word *args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcLines* ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines* ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccl1->BboxTopLeftX,ccl1->BboxTopLeftY,
|
|
ccl1->BboxBottomRightX,ccl1->BboxBottomRightY,
|
|
ccl2->BboxTopLeftX,ccl2->BboxTopLeftY,
|
|
ccl2->BboxBottomRightX,ccl2->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst))));
|
|
ccresult = new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//((CcLines*)result.addr) =
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEll_common_border,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEll_common_border,
|
|
// ccl1->GetObj(),ccl2->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_LLL("ll_common_border", ccl1, ccl2);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]common[_]border predicate for CcLines and CcRegions.
|
|
|
|
*/
|
|
|
|
static int lr_common_borderFun(Word *args, Word& result, int message,
|
|
Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
CcRegions* ccr = ((CcRegions *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY,
|
|
ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst))));
|
|
ccresult = new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//((CcLines*)result.addr) =
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSElr_common_border,
|
|
ccl->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSElr_common_border,
|
|
// ccl->GetObj(),ccr->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_LRL("lr_common_border", ccl, ccr);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]common[_]border predicate for CcLines and CcRegions.
|
|
|
|
*/
|
|
|
|
static int rl_common_borderFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
CcLines* ccl = ((CcLines *)args[1].addr);
|
|
|
|
//if bboxes don't intersect, return empty object
|
|
if (!bboxesIntersect(ccr->BboxTopLeftX,ccr->BboxTopLeftY,
|
|
ccr->BboxBottomRightX,ccr->BboxBottomRightY,
|
|
ccl->BboxTopLeftX,ccl->BboxTopLeftY,
|
|
ccl->BboxBottomRightX,ccl->BboxBottomRightY)) {
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
//qp->ResultStorage(s,SetWord(
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst))));
|
|
ccresult = new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//((CcLines*)result.addr) =
|
|
// new CcLines(env->NewObject(clsLines,midLinesConst));
|
|
return 0;
|
|
}
|
|
//bboxes intersect, so prepare to invoke Java method
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSErl_common_border,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErl_common_border,
|
|
// ccr->GetObj(),ccl->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_RLL("rl_common_border", ccr, ccl);
|
|
//result.addr = ccresult;
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
l[_]vertices predicate for CcLines.
|
|
|
|
*/
|
|
|
|
static int l_verticesFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccresult;
|
|
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEl_vertices,
|
|
ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEl_vertices,
|
|
// ccl->GetObj()));
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
((CcLines*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//ccresult = callJMethod_LP("l_vertices", ccl);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]vertices predicate for CcRegions.
|
|
|
|
*/
|
|
|
|
static int r_verticesFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccresult;
|
|
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcPoints*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEr_vertices,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsPoints,midPointsConst);
|
|
}
|
|
ccresult = new CcPoints(obj);
|
|
//ccresult =
|
|
// new CcPoints(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEr_vertices,
|
|
// ccr->GetObj()));
|
|
((CcPoints*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
//ccresult = callJMethod_RP("r_vertices", ccr);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
l[_]interior predicate for CcLines.
|
|
|
|
*/
|
|
|
|
static int l_interiorFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccresult;
|
|
|
|
CcLines* ccl = ((CcLines *)args[0].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra, midROSEl_interior,
|
|
ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRegions,midRegionsConstVoid);
|
|
}
|
|
ccresult = new CcRegions(obj);
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]contour predicate for CcRegions.
|
|
|
|
*/
|
|
|
|
static int r_contourFun(Word *args, Word& result,
|
|
int message, Word& local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccresult;
|
|
|
|
CcRegions* ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
//delete (CcLines*)result.addr;
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEr_contour,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsLines,midLinesConst);
|
|
}
|
|
ccresult = new CcLines(obj);
|
|
//ccresult =
|
|
// new CcLines(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEr_contour,
|
|
// ccr->GetObj()));
|
|
((CcRegions*)result.addr)->CopyFrom(ccresult);
|
|
delete ccresult;
|
|
ccresult = 0;
|
|
//qp->ResultStorage(s,SetWord(ccresult));
|
|
|
|
//ccresult = callJMethod_RL("r_contour", ccr);
|
|
//result.addr = ccresult;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
p[_]no[_]of[_]components predicate for CcPoints.
|
|
|
|
*/
|
|
|
|
static int p_no_of_componentsFun(Word *args, Word &result,
|
|
int message, Word &local,
|
|
Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp = ((CcPoints *)args[0].addr);
|
|
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
|
|
//((CcInt *)result.addr)->
|
|
// Set(true, callJMethod_PI("p_no_of_components", ccp));
|
|
jint obj = env->CallStaticIntMethod(clsROSEAlgebra,
|
|
midROSEp_no_of_components,
|
|
ccp->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcInt*)result.addr)->Set(true,obj);
|
|
//((CcInt*)result.addr)->
|
|
// Set(true,env->CallStaticIntMethod(clsROSEAlgebra,
|
|
// midROSEp_no_of_components,
|
|
// ccp->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
l[_]no[_]of[_]components predicate for CcLines.
|
|
|
|
*/
|
|
|
|
static int l_no_of_componentsFun(Word *args, Word &result,
|
|
int message, Word &local,
|
|
Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl = ((CcLines *)args[0].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jint obj = env->CallStaticIntMethod(clsROSEAlgebra,
|
|
midROSEl_no_of_components,
|
|
ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcInt*)result.addr)->Set(true,obj);
|
|
//((CcInt*)result.addr)->
|
|
// Set(true,env->CallStaticIntMethod(clsROSEAlgebra,
|
|
// midROSEl_no_of_components,
|
|
// ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]no[_]of[_]components predicate for CcPoints.
|
|
|
|
*/
|
|
|
|
static int r_no_of_componentsFun(Word *args, Word &result,
|
|
int message, Word &local,
|
|
Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jint obj = env->CallStaticIntMethod(clsROSEAlgebra,
|
|
midROSEr_no_of_components,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcInt*)result.addr)->Set(true,obj);
|
|
//((CcInt*)result.addr)->
|
|
// Set(true,env->CallStaticIntMethod(clsROSEAlgebra,
|
|
// midROSEr_no_of_components,
|
|
// ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pp[_]dist predicate for two CcPoints
|
|
|
|
*/
|
|
|
|
static int pp_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp1 = ((CcPoints *)args[0].addr);
|
|
CcPoints *ccp2 = ((CcPoints *)args[1].addr);
|
|
|
|
if (!ccp1->GetObject()) ccp1->RestoreJavaObjectFromFLOB();
|
|
if (!ccp2->GetObject()) ccp2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra, midROSEpp_dist,
|
|
ccp1->GetObj(),ccp2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
((CcReal*)result.addr)->
|
|
Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
midROSEpp_dist,
|
|
ccp1->GetObj(),
|
|
ccp2->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pl[_]dist predicate for CcPoints and CcLines
|
|
|
|
*/
|
|
|
|
static int pl_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp = ((CcPoints *)args[0].addr);
|
|
CcLines *ccl = ((CcLines *)args[1].addr);
|
|
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpl_dist,
|
|
ccp->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEpl_dist,
|
|
// ccp->GetObj(),
|
|
// ccl->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
pr[_]dist predicate for CcPoints and CcRegions
|
|
|
|
*/
|
|
|
|
static int pr_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp = ((CcPoints *)args[0].addr);
|
|
CcRegions *ccr = ((CcRegions *)args[1].addr);
|
|
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEpr_dist,
|
|
ccp->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEpr_dist,
|
|
// ccp->GetObj(),
|
|
// ccr->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lp[_]dist predicate for CcLines and CcPoints
|
|
|
|
*/
|
|
|
|
static int lp_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl = ((CcLines *)args[0].addr);
|
|
CcPoints *ccp = ((CcPoints *)args[1].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSElp_dist,
|
|
ccl->GetObj(),ccp->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSElp_dist,
|
|
// ccl->GetObj(),
|
|
// ccp->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
ll[_]dist predicate for two CcLines.
|
|
|
|
*/
|
|
|
|
static int ll_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl1 = ((CcLines *)args[0].addr);
|
|
CcLines *ccl2 = ((CcLines *)args[1].addr);
|
|
|
|
if (!ccl1->GetObject()) ccl1->RestoreJavaObjectFromFLOB();
|
|
if (!ccl2->GetObject()) ccl2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEll_dist,
|
|
ccl1->GetObj(),ccl2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEll_dist,
|
|
// ccl1->GetObj(),
|
|
// ccl2->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
lr[_]dist predicate for CcLines and CcRegions.
|
|
|
|
*/
|
|
|
|
static int lr_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl = ((CcLines *)args[0].addr);
|
|
CcRegions *ccr = ((CcRegions *)args[1].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSElr_dist,
|
|
ccl->GetObj(),ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSElr_dist,
|
|
// ccl->GetObj(),
|
|
// ccr->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rp[_]dist predicate for CcRegions and CcPoints.
|
|
|
|
*/
|
|
|
|
static int rp_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
CcPoints *ccp = ((CcPoints *)args[1].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErp_dist,
|
|
ccr->GetObj(),ccp->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErp_dist,
|
|
// ccr->GetObj(),
|
|
// ccp->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rl[_]dist predicate for CcRegions and CcLines.
|
|
|
|
*/
|
|
|
|
static int rl_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
CcLines *ccl = ((CcLines *)args[1].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErl_dist,
|
|
ccr->GetObj(),ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErl_dist,
|
|
// ccr->GetObj(),
|
|
// ccl->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
rr[_]dist predicate for two CcRegions.
|
|
|
|
*/
|
|
|
|
static int rr_distFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr1 = ((CcRegions *)args[0].addr);
|
|
CcRegions *ccr2 = ((CcRegions *)args[1].addr);
|
|
|
|
if (!ccr1->GetObject()) ccr1->RestoreJavaObjectFromFLOB();
|
|
if (!ccr2->GetObject()) ccr2->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSErr_dist,
|
|
ccr1->GetObj(),ccr2->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSErr_dist,
|
|
// ccr1->GetObj(),
|
|
// ccr2->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
p[_]diameter predicate for a CcPoints.
|
|
|
|
*/
|
|
|
|
static int p_diameterFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcPoints *ccp = ((CcPoints *)args[0].addr);
|
|
|
|
if (!ccp->GetObject()) ccp->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEp_diameter,
|
|
ccp->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEp_diameter,
|
|
// ccp->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
l[_]diameter predicate for a CcLines.
|
|
|
|
*/
|
|
|
|
static int l_diameterFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl = ((CcLines *)args[0].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
//debug(__LINE__);
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEl_diameter,
|
|
ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEl_diameter,
|
|
// ccl->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]diameter predicate for a CcRegions.
|
|
|
|
*/
|
|
|
|
static int r_diameterFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
//debug(__LINE__);
|
|
result = qp->ResultStorage(s);
|
|
jobject obj = env->CallStaticObjectMethod(clsROSEAlgebra,midROSEr_diameter,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = env->NewObject(clsRationalFactory,midRFConstRational,-1);
|
|
}
|
|
((CcReal*)result.addr)->Set(true,convertRational(obj));
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,convertRational(env->CallStaticObjectMethod(clsROSEAlgebra,
|
|
// midROSEr_diameter,
|
|
// ccr->GetObj())));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
l[_]ength predicate for a CcLines.
|
|
|
|
*/
|
|
|
|
static int l_lengthFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcLines *ccl = ((CcLines *)args[0].addr);
|
|
|
|
if (!ccl->GetObject()) ccl->RestoreJavaObjectFromFLOB();
|
|
|
|
//debug(__LINE__);
|
|
result = qp->ResultStorage(s);
|
|
jdouble obj = env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEl_length,
|
|
ccl->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcReal*)result.addr)->Set(true,obj);
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEl_length,
|
|
// ccl->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]aera predicate for a CcRegions.
|
|
|
|
*/
|
|
|
|
static int r_areaFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jdouble obj = env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEr_area,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcReal*)result.addr)->Set(true,obj);
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEr_area,
|
|
// ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
r[_]perimeter predicate for a CcRegions.
|
|
|
|
*/
|
|
|
|
static int r_perimeterFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcRegions *ccr = ((CcRegions *)args[0].addr);
|
|
|
|
if (!ccr->GetObject()) ccr->RestoreJavaObjectFromFLOB();
|
|
|
|
result = qp->ResultStorage(s);
|
|
jdouble obj = env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEr_perimeter,
|
|
ccr->GetObj());
|
|
if (env->ExceptionOccurred()) {
|
|
RoseError();
|
|
obj = -1;
|
|
}
|
|
((CcReal*)result.addr)->Set(true,obj);
|
|
//((CcReal*)result.addr)->
|
|
// Set(true,env->CallStaticDoubleMethod(clsROSEAlgebra,midROSEr_perimeter,
|
|
// ccr->GetObj()));
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
The setDeviationValue operation is used to set the deviation value for the ROSE algebra.
|
|
|
|
*/
|
|
|
|
static int setDeviationValueFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcReal *realval = ((CcReal *)args[0].addr);
|
|
result = qp->ResultStorage(s);
|
|
|
|
callSetDeviationValue(realval);
|
|
((CcBool *)result.addr)->Set(true, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
chooseTriangulator can be used to choose between different triangulators.
|
|
|
|
*/
|
|
|
|
static int chooseTriangulatorFun(Word *args, Word &result, int message,
|
|
Word &local, Supplier s) {
|
|
if (DEBUG) cout << "entered " << __PRETTY_FUNCTION__ << endl;
|
|
CcInt *intval = ((CcInt *)args[0].addr);
|
|
result = qp->ResultStorage(s);
|
|
|
|
callChooseTriangulator(intval);
|
|
((CcBool *)result.addr)->Set(true, true);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
5.4 Definition of Operators
|
|
|
|
*/
|
|
|
|
//predicates
|
|
ValueMapping equalMap[] = { pp_equalFun,
|
|
ll_equalFun,
|
|
rr_equalFun };
|
|
ValueMapping unequalMap[] = { pp_unequalFun,
|
|
ll_unequalFun,
|
|
rr_unequalFun };
|
|
ValueMapping disjointMap[] = { pp_disjointFun,
|
|
ll_disjointFun,
|
|
rr_disjointFun };
|
|
ValueMapping insideMap[] = { pr_insideFun,
|
|
lr_insideFun,
|
|
rr_insideFun };
|
|
ValueMapping intersectsMap[] = { ll_intersectsFun,
|
|
lr_intersectsFun,
|
|
rl_intersectsFun,
|
|
rr_intersectsFun };
|
|
ValueMapping meetsMap[] = { ll_meetsFun,
|
|
lr_meetsFun,
|
|
rl_meetsFun,
|
|
rr_meetsFun };
|
|
ValueMapping borderInCommonMap[] = { ll_border_in_commonFun,
|
|
lr_border_in_commonFun,
|
|
rl_border_in_commonFun,
|
|
rr_border_in_commonFun };
|
|
ValueMapping onBorderOfMap[] = { pl_on_border_ofFun,
|
|
pr_on_border_ofFun };
|
|
|
|
//operations
|
|
ValueMapping intersectionMap[] = { pp_intersectionFun,
|
|
ll_intersectionFun,
|
|
rr_intersectionFun,
|
|
rl_intersectionFun };
|
|
ValueMapping plusMap[] = { pp_plusFun,
|
|
ll_plusFun,
|
|
rr_plusFun };
|
|
ValueMapping minusMap[] = { pp_minusFun,
|
|
ll_minusFun,
|
|
rr_minusFun };
|
|
ValueMapping commonBorderMap[] = { ll_common_borderFun,
|
|
lr_common_borderFun,
|
|
rl_common_borderFun,
|
|
rr_common_borderFun };
|
|
ValueMapping verticesMap[] = { l_verticesFun,
|
|
r_verticesFun };
|
|
ValueMapping noOfComponentsMap[] = { p_no_of_componentsFun,
|
|
l_no_of_componentsFun,
|
|
r_no_of_componentsFun };
|
|
ValueMapping distMap[] = { pp_distFun,
|
|
pl_distFun,
|
|
pr_distFun,
|
|
lp_distFun,
|
|
ll_distFun,
|
|
lr_distFun,
|
|
rp_distFun,
|
|
rl_distFun,
|
|
rr_distFun };
|
|
ValueMapping diameterMap[] = { p_diameterFun,
|
|
l_diameterFun,
|
|
r_diameterFun };
|
|
|
|
const string equalSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>({rpoints,rline,rregion} x {rpoints,rline,rregion} -> bool</text--->"
|
|
"<text>o1 equal o2, where o1,o2 are objects of type "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>The equal predicate returns true, if both objects "
|
|
"are equal.</text--->"
|
|
"<text>query Rhein equal Weser</text--->"
|
|
") )";
|
|
|
|
const string unequalSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>({rpoints,rline,rregion} x {rpoints,rline,rregion} -> bool</text--->"
|
|
"<text>o1 unequal o2, where o1,o2 are objects of type "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>The unequal predicate returns true, if both objects "
|
|
"are not equal.</text--->"
|
|
"<text>query Rhein unequal Weser</text--->"
|
|
") )";
|
|
|
|
const string disjointSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>({rpoints,rline,rregion} x {rpoints,rline,rregion} -> bool</text--->"
|
|
"<text>o1 disjoint o2, where o1,o2 are objects of type "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>The disjoint predicate returns true, if both objects "
|
|
"have no common points.</text--->"
|
|
"<text>query Rhein disjoint Weser</text--->"
|
|
") )";
|
|
|
|
const string insideSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>({rpoints,rline,rregion} x rregion -> bool</text--->"
|
|
"<text>o inside r, where o is an object of type "
|
|
"{rpoints,rline,rregion} and r is a rregion.</text--->"
|
|
"<text>The inside predicate returns true, if o lies inside of r</text--->"
|
|
"<text>query Rhein inside LKMagdeburg</text--->"
|
|
") )";
|
|
|
|
const string areaDisjointSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion x egion -> bool</text--->"
|
|
"<text>r1 area_disjoint r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The area_disjoint predicate returns true, if "
|
|
"r1,r2 have no common area.</text--->"
|
|
"<text>query LKMagdeburg area_disjoint SKKiel</text--->"
|
|
") )";
|
|
|
|
const string edgeDisjointSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>egion x rregion -> bool</text--->"
|
|
"<text>r1 edge_disjoint r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The edge_disjoint predicate returns true, if "
|
|
"r1,r2 have no common edges.</text--->"
|
|
"<text>query LKMagdeburg edge_disjoint SKKiel</text--->"
|
|
") )";
|
|
|
|
const string edgeInsideSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion x rregion -> bool</text--->"
|
|
"<text>r1 edge_inside r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The edge_inside predicate returns true, if no "
|
|
"edges of r1 are inside of r2.</text--->"
|
|
"<text>query LKMagdeburg edge_inside SKKiel</text--->"
|
|
") )";
|
|
|
|
const string vertexInsideSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion x rregion -> bool</text--->"
|
|
"<text>r1 vertex_inside r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The vertex_inside predicate returns true, if no "
|
|
"vertex of r1 is inside of r2.</text--->"
|
|
"<text>query LKMagdeburg vertex_inside SKKiel</text--->"
|
|
") )";
|
|
|
|
const string intersectsSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rline,rregion} x {rline,rregion} -> bool</text--->"
|
|
"<text>o1 intersects o2, where o1,o2 are of type {rline,rregion}</text--->"
|
|
"<text>The intersects predicate returns true, if o1,o2 intersect</text--->"
|
|
"<text>query Rhein intersects Main</text--->"
|
|
") )";
|
|
|
|
const string meetsSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rline,rregion} x {rline,rregion} -> bool</text--->"
|
|
"<text>o1 meets o2, where o1,o2 are of type {rline,rregion}</text--->"
|
|
"<text>The meets predicate returns true, if o1,o2 meet in one point</text--->"
|
|
"<text>query Rhein meets Weser</text--->"
|
|
") )";
|
|
|
|
const string borderInCommonSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rline,rregion} x {rline,rregion} -> bool</text--->"
|
|
"<text>o1 border_in_common o2, where o1,o2 are"
|
|
" of type {rline,rregion}</text--->"
|
|
"<text>The border_in_common predicate returns true, if "
|
|
"o1,o2 have a common border.</text--->"
|
|
"<text>query LKSteinfurt border_in_common LKMagdeburg</text--->"
|
|
") )";
|
|
|
|
const string adjacentSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion x rregion -> bool</text--->"
|
|
"<text>r1 adjacent r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The adjacent predicate returns true, if r1,r2 have a "
|
|
"common border, but don't have a common area</text--->"
|
|
"<text>query LKSteinfurt adjacent LKMagdeburg</text--->"
|
|
") )";
|
|
|
|
const string enclosesSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion x rregion -> bool</text--->"
|
|
"<text>r1 encloses r2, where r1,r2 are of type rregion</text--->"
|
|
"<text>The encloses predicate returns true, if r2 "
|
|
"completely lies in holes of r1</text--->"
|
|
"<text>query LKOsnabrueck encloses SKOsnabrueck</text--->"
|
|
") )";
|
|
|
|
const string intersectionSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} x {rpoints,rline,rregion} -> "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>intersection(o1,o2), where both objects "
|
|
"have to be of the same type. "
|
|
"The result type of rpoints x rpoints is rpoints, "
|
|
"the result type of rline x rline "
|
|
"is rpoints and the result type of rregion x rregion is rregion.</text--->"
|
|
"<text>The intersection operation returns the geometric intersection "
|
|
"of two objects.</text--->"
|
|
"<text>query intersection(Rhein,Weser)(</text--->"
|
|
") )";
|
|
|
|
const string plusSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} x {rpoints,rline,rregion} -> "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>o1 plus o2, where o1,o2 and the result are of the same type "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>The plus operation returns the geometric sum of two objects</text--->"
|
|
"<text>query LKOsnabrueck plus SKOsnabrueck</text--->"
|
|
") )";
|
|
|
|
const string minusSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} x {rpoints,rline,rregion} -> "
|
|
"{rpoints,rline,regin}</text--->"
|
|
"<text>o1 minus o2, where o1,o2 and the result are of the same type "
|
|
"{rpoints,rline,rregion}</text--->"
|
|
"<text>The minus operation returns the geometric difference of "
|
|
"two objects</text--->"
|
|
"<text>query LKSteinfurt minus LKOsnabrueck</text--->"
|
|
") )";
|
|
|
|
const string commonBorderSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rline,rregion} x {rline,rregion} -> rline</text--->"
|
|
"<text>common_border(o1,o2), where o1,o2 are of type {rline,rregion}</text--->"
|
|
"<text>The common_border operation returns the common part of the "
|
|
"borders or rline objects, resp.</text--->"
|
|
"<text>query common_border(LKSteinfurt,SKOsnabrueck)</text--->"
|
|
") )";
|
|
|
|
const string onBorderOfSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rpoints x {rline,rregion} -> bool</text--->"
|
|
"<text>p on_border_of o, where p is a rpoints value and o is of type "
|
|
"{rline,rregion}</text--->"
|
|
"<text>The on_border_of predicate returns true, if p completely "
|
|
"lies on o</text--->"
|
|
"<text>query Koeln on_border_of autobahn3</text--->"
|
|
") )";
|
|
|
|
const string verticesSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rline,rregion} -> rpoints</text--->"
|
|
"<text>vertices (o), where o is of type {rline,rregion}</text--->"
|
|
"<text>The vertices operation return the vertices of the o value</text--->"
|
|
"<text>query vertices (magdeburg)</text--->"
|
|
") )";
|
|
|
|
const string interiorSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rline -> rregion</text--->"
|
|
"<text>interior(l), where l has type rline</text--->"
|
|
"<text>The interior operation returns the rregion that is "
|
|
"enclosed by l.</text--->"
|
|
"<text>qeury interior(borderOfLKMagdeburg)</text--->"
|
|
") )";
|
|
|
|
const string contourSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion -> rline</text--->"
|
|
"<text>contour (r), where r has type rregion</text--->"
|
|
"<text>The contour operation returns the border or r without holes.</text--->"
|
|
"<text>query contour (magdeburg)</text--->"
|
|
") )";
|
|
|
|
const string noOfComponentsSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} -> int</text--->"
|
|
"<text>no_of_components (o), where o is of "
|
|
"type {rpoints,rline,rregion}</text--->"
|
|
"<text>The no_of_components operation counts the number of connected "
|
|
"components and returns that number.</text--->"
|
|
"<text>query no_of_components (Rhein)</text--->"
|
|
") )";
|
|
|
|
const string distSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} -> real</text--->"
|
|
"<text>dist(o1,o2), where o1,o2 are of type {rpoints,rline,rregion}</text--->"
|
|
"<text>The dist operation returns the Eucledian distance "
|
|
"between o1,o2.</text--->"
|
|
"<text>query dist(LKSteinfurt,Rhein)</text--->"
|
|
") )";
|
|
|
|
const string diameterSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>{rpoints,rline,rregion} -> real</text--->"
|
|
"<text>diameter (o), where o is of type {rpoints,rline,rregion}</text--->"
|
|
"<text>The diameter operation returns the diameter of o.</text--->"
|
|
"<text>query diameter (Rhein)</text--->"
|
|
") )";
|
|
|
|
const string lengthSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rline -> real</text--->"
|
|
"<text>length (l), where l is of type rline</text--->"
|
|
"<text>The length operation return the lenght of a rline object.</text--->"
|
|
"<text>query length (Rhein)</text--->"
|
|
") )";
|
|
|
|
const string areaSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion -> real</text--->"
|
|
"<text>area (r), where r is of type rregion</text--->"
|
|
"<text>The area operation returns a real value for the area of r.</text--->"
|
|
"<text>query area (magdeburg)</text--->"
|
|
") )";
|
|
|
|
const string perimeterSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>rregion -> real</text--->"
|
|
"<text>perimeter (r), where r is of type rregion</text--->"
|
|
"<text>The perimeter operation returns a real value for the "
|
|
"perimeter of r.</text--->"
|
|
"<text>query perimeter (magdeburg)</text--->"
|
|
") )";
|
|
|
|
const string setDeviationValueSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>double -> bool</text--->"
|
|
"<text>setDeviationValue(d), d is a double value</text--->"
|
|
"<text>Sets the deviation value for the ROSE-Algebra.</text--->"
|
|
"<text>query setDeviationValue(0.000001)</text--->"
|
|
") )";
|
|
|
|
const string chooseTriangulatorSpec =
|
|
"( ( \"Signature\" \"Syntax\" \"Meaning\" "
|
|
"\"Example\" )"
|
|
"( <text>int -> bool</text--->"
|
|
"<text>chooseTriangulator(i), i is an integer value</text--->"
|
|
"<text>Chooses the triangulator of the ROSE algebra. "
|
|
"0 = Mehlhorn (default), 1 = Triangle, 2 = NetGen.</text--->"
|
|
"<text>query chooseTriangulator(1)</text--->"
|
|
") )";
|
|
|
|
/*
|
|
Used to explain the signature and the meaning of the implemented operators.
|
|
|
|
*/
|
|
|
|
Operator ROSEequal (
|
|
"=", //name
|
|
equalSpec, //specification
|
|
3, //number of functions
|
|
equalMap, //value mapping
|
|
equalSelect, //selection function
|
|
equalTypeMap); //type mapping function
|
|
|
|
Operator ROSEunequal (
|
|
"#", //name
|
|
unequalSpec, //specification
|
|
3, //number of functions
|
|
unequalMap, //value mapping
|
|
unequalSelect, //selection function
|
|
unequalTypeMap); //type mapping function
|
|
|
|
Operator ROSEdisjoint (
|
|
"disjoint", //name
|
|
disjointSpec, //specification
|
|
3, //number of functions
|
|
disjointMap, //value mapping
|
|
disjointSelect, //selection function
|
|
disjointTypeMap); //type mapping function
|
|
|
|
Operator ROSEinside (
|
|
"inside", //name
|
|
insideSpec, //specification
|
|
3, //number of functions
|
|
insideMap, //value mapping
|
|
insideSelect, //selection function
|
|
insideTypeMap); //type mapping function
|
|
|
|
Operator ROSEarea_disjoint (
|
|
"area_disjoint", //name
|
|
areaDisjointSpec, //specification
|
|
rr_area_disjointFun, //value mapping
|
|
simpleSelect, //selection function
|
|
ccregionsccregionsBool); //type mapping function
|
|
|
|
Operator ROSEedge_disjoint (
|
|
"edge_disjoint", //name
|
|
edgeDisjointSpec, //specification
|
|
rr_edge_disjointFun, //value mapping
|
|
simpleSelect, //selection function
|
|
ccregionsccregionsBool); //type mapping function
|
|
|
|
Operator ROSEedge_inside (
|
|
"edge_inside", //name
|
|
edgeInsideSpec, //specification
|
|
rr_edge_insideFun, //value mapping
|
|
simpleSelect, //selection function
|
|
ccregionsccregionsBool); //type mapping function
|
|
|
|
Operator ROSEvertex_inside (
|
|
"vertex_inside", //name
|
|
vertexInsideSpec, //specification
|
|
rr_vertex_insideFun, //value mapping
|
|
simpleSelect, //selection function
|
|
ccregionsccregionsBool); //type mapping function
|
|
|
|
Operator ROSEintersects (
|
|
"intersects", //name
|
|
intersectsSpec, //specification
|
|
4, //number of functions
|
|
intersectsMap, //value mapping
|
|
intersectsSelect, //selection function
|
|
intersectsTypeMap); //type mapping function
|
|
|
|
Operator ROSEmeets (
|
|
"meets", //name
|
|
meetsSpec, //specification
|
|
4, //number of functions
|
|
meetsMap, //value mapping
|
|
meetsSelect, //selection function
|
|
meetsTypeMap); //type mapping function
|
|
|
|
Operator ROSEborderInCommon (
|
|
"border_in_common", //name
|
|
borderInCommonSpec, //specification
|
|
4, //number of functions
|
|
borderInCommonMap, //value mapping
|
|
borderInCommonSelect, //selection function
|
|
borderInCommonTypeMap); //type mapping function
|
|
|
|
Operator ROSEonBorderOf (
|
|
"on_border_of", //name
|
|
onBorderOfSpec, //specification
|
|
2, //number of functions
|
|
onBorderOfMap, //value mapping
|
|
onBorderOfSelect, //selection function
|
|
onBorderOfTypeMap); //type mapping function
|
|
|
|
Operator ROSEintersection (
|
|
"intersection", //name
|
|
intersectionSpec, //specification
|
|
4, //number of functions
|
|
intersectionMap, //value mapping
|
|
intersectionSelect, //selection function
|
|
intersectionTypeMap); //type mapping function
|
|
|
|
Operator ROSEplus (
|
|
"plus", //name
|
|
plusSpec, //specification
|
|
3, //number of functions
|
|
plusMap, //value mapping
|
|
plusSelect, //selection function
|
|
plusTypeMap); //type mapping function
|
|
|
|
Operator ROSEminus (
|
|
"minus", //name
|
|
minusSpec, //specification
|
|
3, //number of functions
|
|
minusMap, //value mapping
|
|
minusSelect, //selection function
|
|
minusTypeMap); //type mapping function
|
|
|
|
Operator ROSEcommonBorder (
|
|
"common_border", //name
|
|
commonBorderSpec, //specification
|
|
4, //number of functions
|
|
commonBorderMap, //value mapping
|
|
commonBorderSelect, //selection function
|
|
commonBorderTypeMap);//type mapping function
|
|
|
|
Operator ROSEvertices (
|
|
"vertices", //name
|
|
verticesSpec, //specification
|
|
2, //number of functions
|
|
verticesMap, //value mapping
|
|
verticesSelect, //selection function
|
|
verticesTypeMap); //type mapping function
|
|
|
|
Operator ROSEnoOfComponents (
|
|
"no_of_components", //name
|
|
noOfComponentsSpec, //specification
|
|
3, //number of functions
|
|
noOfComponentsMap, //value mapping
|
|
noOfComponentsSelect, //selection function
|
|
noOfComponentsTypeMap); //type mapping function
|
|
|
|
Operator ROSEdist (
|
|
"dist", //name
|
|
distSpec, //specification
|
|
9, //number of functions
|
|
distMap, //value mapping
|
|
distSelect, //selection function
|
|
distTypeMap); //type mapping function
|
|
|
|
Operator ROSEadjacent (
|
|
"adjacent", //name
|
|
adjacentSpec, //specification
|
|
rr_adjacentFun, //value mapping
|
|
simpleSelect, //selection function
|
|
ccregionsccregionsBool); //type mapping function
|
|
|
|
Operator ROSEencloses (
|
|
"encloses", //name
|
|
enclosesSpec, //specification
|
|
rr_enclosesFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
ccregionsccregionsBool //type mapping
|
|
);
|
|
|
|
|
|
|
|
Operator ROSEinterior (
|
|
"interior", //name
|
|
interiorSpec, //specification
|
|
l_interiorFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
cclinesccregions //type mapping
|
|
);
|
|
|
|
Operator ROSEcontour (
|
|
"contour", //name
|
|
contourSpec, //specification ....
|
|
r_contourFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
ccregionscclines //type mapping
|
|
);
|
|
|
|
Operator ROSElength (
|
|
"length", //name
|
|
lengthSpec, //specification ....
|
|
l_lengthFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
cclinesDouble //type mapping
|
|
);
|
|
|
|
Operator ROSEarea (
|
|
"area", //name
|
|
areaSpec, //specification ....
|
|
r_areaFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
ccregionsDouble //type mapping
|
|
);
|
|
|
|
Operator ROSEperimeter (
|
|
"perimeter", //name
|
|
perimeterSpec, //specification ....
|
|
r_perimeterFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
ccregionsDouble //type mapping
|
|
);
|
|
|
|
Operator ROSEdiameter (
|
|
"diameter", //name
|
|
diameterSpec, //specification ...
|
|
3, //number of functions
|
|
diameterMap, //value mapping
|
|
diameterSelect, //selection function
|
|
diameterTypeMap); //type mapping function
|
|
|
|
Operator setDeviationValue (
|
|
"setDeviationValue", //name
|
|
setDeviationValueSpec, //specification ....
|
|
setDeviationValueFun, //value mapping
|
|
simpleSelect, //trivial selection function
|
|
doubleBool //type mapping
|
|
);
|
|
|
|
Operator chooseTriangulator (
|
|
"chooseTriangulator", //name
|
|
chooseTriangulatorSpec, //specification ....
|
|
chooseTriangulatorFun, //value mapping
|
|
simpleSelect, //trivial sel. function
|
|
intBool //type mapping
|
|
);
|
|
|
|
/*
|
|
6 Creating the Algebra
|
|
|
|
*/
|
|
|
|
class RoseAlgebra : public Algebra {
|
|
public:
|
|
RoseAlgebra() : Algebra() {
|
|
AddTypeConstructor(&ccpoints);
|
|
AddTypeConstructor(&cclines);
|
|
AddTypeConstructor(&ccregions);
|
|
ccpoints.AssociateKind(Kind::DATA());
|
|
cclines.AssociateKind(Kind::DATA());
|
|
ccregions.AssociateKind(Kind::DATA());
|
|
/* this means that ccpoints, cclines, ccregions
|
|
can be used in places where types of DATA are expected,
|
|
e. g. in tuples. */
|
|
AddOperator(&ROSEequal);
|
|
AddOperator(&ROSEunequal);
|
|
AddOperator(&ROSEdisjoint);
|
|
AddOperator(&ROSEinside);
|
|
AddOperator(&ROSEarea_disjoint);
|
|
AddOperator(&ROSEedge_disjoint);
|
|
AddOperator(&ROSEedge_inside);
|
|
AddOperator(&ROSEvertex_inside);
|
|
AddOperator(&ROSEintersects);
|
|
AddOperator(&ROSEmeets);
|
|
AddOperator(&ROSEborderInCommon);
|
|
AddOperator(&ROSEonBorderOf);
|
|
AddOperator(&ROSEintersection);
|
|
AddOperator(&ROSEplus);
|
|
AddOperator(&ROSEminus);
|
|
AddOperator(&ROSEcommonBorder);
|
|
AddOperator(&ROSEvertices);
|
|
AddOperator(&ROSEnoOfComponents);
|
|
AddOperator(&ROSEdist);
|
|
AddOperator(&ROSEadjacent);
|
|
AddOperator(&ROSEencloses);
|
|
AddOperator(&ROSEinterior);
|
|
AddOperator(&ROSEcontour);
|
|
AddOperator(&ROSElength);
|
|
AddOperator(&ROSEarea);
|
|
AddOperator(&ROSEperimeter);
|
|
AddOperator(&ROSEdiameter);
|
|
|
|
AddOperator(&setDeviationValue);
|
|
AddOperator(&chooseTriangulator);
|
|
}
|
|
~RoseAlgebra() {};
|
|
};
|
|
|
|
RoseAlgebra roseAlgebra;
|
|
|
|
/*
|
|
7 Initialization
|
|
|
|
Each algebra module needs an initialization function. The algebra manager
|
|
has a reference to this function if this algebra is included in the list
|
|
of required algebras, thus forcing the linker to include this module.
|
|
|
|
The algebra manager invokes this function to get a reference to the instance
|
|
of the algebra class and to provide references to the global nested list
|
|
container (used to store constructor, type, operator and object information)
|
|
and to the query processor.
|
|
|
|
The function has a C interface to make it possible to load the algebra
|
|
dynamically at runtime.
|
|
|
|
*/
|
|
|
|
extern "C"
|
|
Algebra*
|
|
InitializeRoseAlgebra( NestedList* nlRef, QueryProcessor* qpRef )
|
|
{
|
|
//Get the pointers env and jvm from the used Java Virtual Machine.
|
|
jvminit = new JVMInitializer();
|
|
env = jvminit->getEnv();
|
|
jvm = jvminit->getJVM();
|
|
|
|
clsRationalFactory = env->FindClass("twodsack/util/number/RationalFactory");
|
|
if (clsRationalFactory == 0) error(__FILE__,__LINE__);
|
|
|
|
//set Rational class
|
|
jmethodID midRatFac = env->GetStaticMethodID(clsRationalFactory,
|
|
"setClass",
|
|
"(Ljava/lang/String;)V");
|
|
if (midRatFac == 0) error(__FILE__,__LINE__);
|
|
|
|
jstring jstr = env->NewStringUTF("twodsack.util.number.RationalDouble");
|
|
if (jstr == 0) error(__FILE__,__LINE__);
|
|
|
|
env->CallStaticVoidMethod(clsRationalFactory, midRatFac, jstr);
|
|
|
|
jmethodID midPrecision = env->GetStaticMethodID(clsRationalFactory,
|
|
"setPrecision", "(Z)V");
|
|
if (midPrecision == 0) error(__FILE__,__LINE__);
|
|
|
|
env->CallStaticVoidMethod(clsRationalFactory, midPrecision, false);
|
|
|
|
jmethodID midSetDeviation = env->GetStaticMethodID(clsRationalFactory,
|
|
"setDeviationDouble",
|
|
"(D)V");
|
|
if (midSetDeviation == 0) error(__FILE__,__LINE__);
|
|
|
|
//set deviation value for 2DSACK package
|
|
DEVIATION_VALUE = 0.0000000001;
|
|
env->CallStaticVoidMethod(clsRationalFactory,
|
|
midSetDeviation,
|
|
DEVIATION_VALUE);
|
|
|
|
jmethodID midReadDeviation = env->GetStaticMethodID(clsRationalFactory,
|
|
"readDeviationDouble",
|
|
"()D");
|
|
if (midReadDeviation == 0) error(__FILE__,__LINE__);
|
|
|
|
jmethodID midReadDeviationN =
|
|
env->GetStaticMethodID(clsRationalFactory,
|
|
"readDeviationDoubleNeg", "()D");
|
|
if (midReadDeviationN == 0) error(__FILE__,__LINE__);
|
|
|
|
jdouble resD = env->CallStaticDoubleMethod(clsRationalFactory,
|
|
midReadDeviation);
|
|
jdouble resDN = env->CallStaticDoubleMethod(clsRationalFactory,
|
|
midReadDeviationN);
|
|
|
|
cout << "2DSACK algebra: deviation values set to "
|
|
<< resD << "/" << resDN << endl;
|
|
|
|
//read all the other classes that are needed in here
|
|
clsPoints = env->FindClass("Points");
|
|
if (clsPoints == 0) error(__FILE__,__LINE__);
|
|
|
|
clsLines = env->FindClass("Lines");
|
|
if (clsLines == 0) error(__FILE__,__LINE__);
|
|
|
|
clsRegions = env->FindClass("Regions");
|
|
if (clsRegions == 0) error(__FILE__,__LINE__);
|
|
|
|
clsRational = env->FindClass("twodsack/util/number/Rational");
|
|
if (clsRational == 0) error(__FILE__,__LINE__);
|
|
|
|
clsPoint =
|
|
env->FindClass("twodsack/setelement/datatype/basicdatatype/Point");
|
|
if (clsPoint == 0) error(__FILE__,__LINE__);
|
|
|
|
clsPointMultiSet = env->FindClass("twodsack/set/PointMultiSet");
|
|
if (clsPointMultiSet == 0) error(__FILE__,__LINE__);
|
|
|
|
clsSegment =
|
|
env->FindClass("twodsack/setelement/datatype/basicdatatype/Segment");
|
|
if (clsSegment == 0) error(__FILE__,__LINE__);
|
|
|
|
clsSegMultiSet = env->FindClass("twodsack/set/SegMultiSet");
|
|
if (clsSegMultiSet == 0) error(__FILE__,__LINE__);
|
|
|
|
clsLinkedList = env->FindClass("java/util/LinkedList");
|
|
if (clsLinkedList == 0) error(__FILE__,__LINE__);
|
|
|
|
clsCycleList = env->FindClass("twodsack/util/collection/CycleList");
|
|
if (clsCycleList == 0) error(__FILE__,__LINE__);
|
|
|
|
clsCycleListListPoints =
|
|
env->FindClass("twodsack/util/collection/CycleListListPoints");
|
|
if (clsCycleListListPoints == 0) error(__FILE__,__LINE__);
|
|
|
|
clsSegmentComparator =
|
|
env->FindClass("twodsack/util/comparator/SegmentComparator");
|
|
if (clsSegmentComparator == 0) error(__FILE__,__LINE__);
|
|
|
|
clsROSEAlgebra = env->FindClass("ROSEAlgebra");
|
|
if (clsROSEAlgebra == 0) error(__FILE__,__LINE__);
|
|
|
|
clsRect =
|
|
env->FindClass("twodsack/setelement/datatype/basicdatatype/Rect");
|
|
if (clsRect == 0) error(__FILE__,__LINE__);
|
|
|
|
//define java methods, that are needed
|
|
midRationalGetDouble = env->GetMethodID(clsRational,
|
|
"getDouble",
|
|
"()D");
|
|
if (midRationalGetDouble == 0) error(__FILE__,__LINE__);
|
|
midPMSToArray = env->GetMethodID(clsPointMultiSet,
|
|
"toArray",
|
|
"()[Ljava/lang/Object;");
|
|
if (midPMSToArray == 0) error(__FILE__,__LINE__);
|
|
midSegmentGetStartpoint =
|
|
env->GetMethodID(clsSegment,
|
|
"getStartpoint",
|
|
"()Ltwodsack/setelement/datatype/basicdatatype/Point;");
|
|
if (midSegmentGetStartpoint == 0) error(__FILE__,__LINE__);
|
|
midSegmentGetEndpoint =
|
|
env->GetMethodID(clsSegment,
|
|
"getEndpoint",
|
|
"()Ltwodsack/setelement/datatype/basicdatatype/Point;");
|
|
if (midSegmentGetEndpoint == 0) error(__FILE__,__LINE__);
|
|
midSMSToArray =
|
|
env->GetMethodID(clsSegMultiSet, "toArray", "()[Ljava/lang/Object;");
|
|
if (midSMSToArray == 0) error(__FILE__,__LINE__);
|
|
midLLToArray =
|
|
env->GetMethodID(clsLinkedList, "toArray", "()[Ljava/lang/Object;");
|
|
if (midLLToArray == 0) error(__FILE__,__LINE__);
|
|
midCLToArray =
|
|
env->GetMethodID(clsCycleList, "toArray", "()[Ljava/lang/Object;");
|
|
if (midCLToArray == 0) error(__FILE__,__LINE__);
|
|
midCLLPToArray =
|
|
env->GetMethodID(clsCycleListListPoints,
|
|
"toArray",
|
|
"()[Ljava/lang/Object;");
|
|
if (midCLLPToArray == 0) error(__FILE__,__LINE__);
|
|
midRegionsCyclesPoints =
|
|
env->GetMethodID(clsRegions,
|
|
"cyclesPoints",
|
|
"()Ltwodsack/util/collection/CycleListListPoints;");
|
|
if (midRegionsCyclesPoints == 0) error(__FILE__,__LINE__);
|
|
midRFConstRational =
|
|
env->GetStaticMethodID(clsRationalFactory,
|
|
"constRational",
|
|
"(II)Ltwodsack/util/number/Rational;");
|
|
if (midRFConstRational == 0) error(__FILE__,__LINE__);
|
|
midPointConstII = env->GetMethodID(clsPoint, "<init>", "(II)V");
|
|
if (midPointConstII == 0) error(__FILE__,__LINE__);
|
|
midPointConstDD = env->GetMethodID(clsPoint, "<init>", "(DD)V");
|
|
if (midPointConstDD == 0) error(__FILE__,__LINE__);
|
|
midPointConstRR =
|
|
env->GetMethodID(clsPoint,
|
|
"<init>",
|
|
"(Ltwodsack/util/number/Rational;"
|
|
"Ltwodsack/util/number/Rational;)V");
|
|
if (midPointConstRR == 0) error(__FILE__,__LINE__);
|
|
midPointsConst = env->GetMethodID(clsPoints, "<init>", "()V");
|
|
if (midPointsConst == 0) error(__FILE__,__LINE__);
|
|
midPointsAddPoint =
|
|
env->GetMethodID(clsPoints,
|
|
"add",
|
|
"(Ltwodsack/setelement/datatype/basicdatatype/Point;)V");
|
|
if (midPointsAddPoint == 0) error(__FILE__,__LINE__);
|
|
midSegmentConstIIII = env->GetMethodID(clsSegment, "<init>", "(IIII)V");
|
|
if (midSegmentConstIIII == 0) error(__FILE__,__LINE__);
|
|
midSegmentConstDDDD = env->GetMethodID(clsSegment, "<init>", "(DDDD)V");
|
|
if (midSegmentConstDDDD == 0) error(__FILE__,__LINE__);
|
|
midSegmentConstRRRR =
|
|
env->GetMethodID(clsSegment,
|
|
"<init>",
|
|
"(Ltwodsack/util/number/Rational;"
|
|
"Ltwodsack/util/number/Rational;"
|
|
"Ltwodsack/util/number/Rational;"
|
|
"Ltwodsack/util/number/Rational;)V");
|
|
if (midSegmentConstRRRR == 0) error(__FILE__,__LINE__);
|
|
midLinesConst = env->GetMethodID(clsLines, "<init>", "()V");
|
|
if (midLinesConst == 0) error(__FILE__,__LINE__);
|
|
midLinesAddSegment =
|
|
env->GetMethodID(clsLines,
|
|
"add",
|
|
"(Ltwodsack/setelement/datatype/basicdatatype/Segment;)V");
|
|
if (midLinesAddSegment == 0) error(__FILE__,__LINE__);
|
|
midSCConst = env->GetMethodID(clsSegmentComparator, "<init>", "()V");
|
|
if (midSCConst == 0) error(__FILE__,__LINE__);
|
|
midSMSConst =
|
|
env->GetMethodID(clsSegMultiSet,
|
|
"<init>",
|
|
"(Ltwodsack/util/comparator/SegmentComparator;)V");
|
|
if (midSMSConst == 0) error(__FILE__,__LINE__);
|
|
midSMSAdd =
|
|
env->GetMethodID(clsSegMultiSet,
|
|
"add",
|
|
"(Ltwodsack/setelement/datatype/basicdatatype/Segment;)V");
|
|
if (midSMSAdd == 0) error(__FILE__,__LINE__);
|
|
midSegmentConstPP =
|
|
env->GetMethodID(clsSegment,
|
|
"<init>",
|
|
"(Ltwodsack/setelement/datatype/basicdatatype/Point;"
|
|
"Ltwodsack/setelement/datatype/basicdatatype/Point;)V");
|
|
if (midSegmentConstPP == 0) error(__FILE__,__LINE__);
|
|
midRegionsConstVoid = env->GetMethodID(clsRegions, "<init>", "()V");
|
|
if (midRegionsConstVoid == 0) error(__FILE__,__LINE__);
|
|
midRegionsConstSMS =
|
|
env->GetMethodID(clsRegions, "<init>", "(Ltwodsack/set/SegMultiSet;)V");
|
|
if (midRegionsConstSMS == 0) error(__FILE__,__LINE__);
|
|
midPointsCompare = env->GetMethodID(clsPoints,"compare","(LPoints;)I");
|
|
if (midPointsCompare == 0) error(__FILE__,__LINE__);
|
|
midPointsWriteToByteArray =
|
|
env->GetMethodID(clsPoints,"writeToByteArray","()[B");
|
|
if(midPointsWriteToByteArray == 0) error(__FILE__,__LINE__);
|
|
midPointsReadFrom =
|
|
env->GetStaticMethodID(clsPoints,"readFrom","([B)LPoints;");
|
|
if(midPointsReadFrom == 0) error(__FILE__,__LINE__);
|
|
midPointsPrint = env->GetMethodID(clsPoints,"print","()V");
|
|
if(midPointsPrint == 0) error(__FILE__,__LINE__);
|
|
midLinesRect =
|
|
env->GetMethodID(clsLines,
|
|
Rectangle<2>::BasicType().c_str(),
|
|
"()Ltwodsack/setelement/datatype/basicdatatype/Rect;");
|
|
if(midLinesRect == 0) error(__FILE__,__LINE__);
|
|
midPointsRect =
|
|
env->GetMethodID(clsPoints,
|
|
Rectangle<2>::BasicType().c_str(),
|
|
"()Ltwodsack/setelement/datatype/basicdatatype/Rect;");
|
|
if(midPointsRect == 0) error(__FILE__,__LINE__);
|
|
midLinesCompare = env->GetMethodID(clsLines,"compare","(LLines;)I");
|
|
if (midLinesCompare == 0) error(__FILE__,__LINE__);
|
|
midLinesWriteToByteArray =
|
|
env->GetMethodID(clsLines,"writeToByteArray","()[B");
|
|
if(midLinesWriteToByteArray == 0) error(__FILE__,__LINE__);
|
|
midLinesReadFrom =
|
|
env->GetStaticMethodID(clsLines,"readFrom","([B)LLines;");
|
|
if(midLinesReadFrom == 0) error(__FILE__,__LINE__);
|
|
midLinesPrint = env->GetMethodID(clsLines,"print","()V");
|
|
if(midLinesPrint == 0) error (__FILE__,__LINE__);
|
|
midRegionsCompare =
|
|
env->GetMethodID(clsRegions,"compare","(LRegions;)I");
|
|
if (midRegionsCompare == 0) error (__FILE__,__LINE__);
|
|
midRegionsWriteToByteArray =
|
|
env->GetMethodID(clsRegions,"writeToByteArray","()[B");
|
|
if(midRegionsWriteToByteArray == 0) error(__FILE__,__LINE__);
|
|
midRegionsReadFrom =
|
|
env->GetStaticMethodID(clsRegions,"readFrom","([B)LRegions;");
|
|
if(midRegionsReadFrom == 0) error(__FILE__,__LINE__);
|
|
midRegionsPrint = env->GetMethodID(clsRegions,"print","()V");
|
|
if(midRegionsPrint == 0) error(__FILE__,__LINE__);
|
|
midRationalGetNumerator =
|
|
env->GetMethodID(clsRational, "getNumerator", "()I");
|
|
if (midRationalGetNumerator == 0) error(__FILE__, __LINE__);
|
|
midRationalGetDenominator =
|
|
env->GetMethodID(clsRational, "getDenominator", "()I");
|
|
if (midRationalGetDenominator == 0) error(__FILE__, __LINE__);
|
|
midROSESetDeviationValue =
|
|
env->GetStaticMethodID(clsROSEAlgebra, "setDeviationValue", "(D)V");
|
|
if (midROSESetDeviationValue == 0) error(__FILE__,__LINE__);
|
|
midROSEChooseTriangulator =
|
|
env->GetStaticMethodID(clsROSEAlgebra, "chooseTriangulator", "(I)V");
|
|
if (midROSEChooseTriangulator == 0) error(__FILE__,__LINE__);
|
|
midRegionsRect =
|
|
env->GetMethodID(clsRegions,
|
|
Rectangle<2>::BasicType().c_str(),
|
|
"()Ltwodsack/setelement/datatype/basicdatatype/Rect;");
|
|
if (midRegionsRect == 0) error(__FILE__,__LINE__);
|
|
midRectGetTopLeftX = env->GetMethodID(clsRect,"getTopLeftX","()D");
|
|
if (midRectGetTopLeftX == 0) error (__FILE__, __LINE__);
|
|
midRectGetTopLeftY = env->GetMethodID(clsRect,"getTopLeftY","()D");
|
|
if (midRectGetTopLeftY == 0) error (__FILE__, __LINE__);
|
|
midRectGetBottomRightX = env->GetMethodID(clsRect,"getBottomRightX","()D");
|
|
if (midRectGetBottomRightX == 0) error (__FILE__, __LINE__);
|
|
midRectGetBottomRightY = env->GetMethodID(clsRect,"getBottomRightY","()D");
|
|
if (midRectGetBottomRightY == 0) error (__FILE__, __LINE__);
|
|
|
|
//define ROSE function mid
|
|
|
|
midROSEp_diameter =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"p_diameter",
|
|
"(LPoints;)Ltwodsack/util/number/Rational;");
|
|
if (midROSEp_diameter == 0) error(__FILE__,__LINE__);
|
|
midROSEp_no_of_components =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"p_no_of_components","(LPoints;)I");
|
|
if (midROSEp_no_of_components == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEl_diameter =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"l_diameter",
|
|
"(LLines;)Ltwodsack/util/number/Rational;");
|
|
if (midROSEl_diameter == 0) error(__FILE__,__LINE__);
|
|
midROSEl_interior =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"l_interior","(LLines;)LRegions;");
|
|
if (midROSEl_interior == 0) error(__FILE__,__LINE__);
|
|
midROSEl_length =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"l_length","(LLines;)D");
|
|
if (midROSEl_length == 0) error(__FILE__,__LINE__);
|
|
midROSEl_no_of_components =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"l_no_of_components","(LLines;)I");
|
|
if (midROSEl_no_of_components == 0) error(__FILE__,__LINE__);
|
|
midROSEl_vertices =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"l_vertices","(LLines;)LPoints;");
|
|
if (midROSEl_vertices == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEr_area =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"r_area","(LRegions;)D");
|
|
if (midROSEr_area == 0) error(__FILE__,__LINE__);
|
|
midROSEr_contour =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"r_contour","(LRegions;)LLines;");
|
|
if (midROSEr_contour == 0) error(__FILE__,__LINE__);
|
|
midROSEr_diameter =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"r_diameter",
|
|
"(LRegions;)Ltwodsack/util/number/Rational;");
|
|
if (midROSEr_diameter == 0) error(__FILE__,__LINE__);
|
|
midROSEr_no_of_components =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"r_no_of_components","(LRegions;)I");
|
|
if (midROSEr_no_of_components == 0) error(__FILE__,__LINE__);
|
|
midROSEr_perimeter =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"r_perimeter","(LRegions;)D");
|
|
if (midROSEr_perimeter == 0) error(__FILE__,__LINE__);
|
|
midROSEr_vertices =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"r_vertices","(LRegions;)LPoints;");
|
|
if (midROSEr_vertices == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEpp_disjoint =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"pp_disjoint","(LPoints;LPoints;)Z");
|
|
if (midROSEpp_disjoint == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pp_dist",
|
|
"(LPoints;LPoints;)Ltwodsack/util/number/Rational;");
|
|
if (midROSEpp_dist == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_equal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"pp_equal","(LPoints;LPoints;)Z");
|
|
if (midROSEpp_equal == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_plus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pp_plus",
|
|
"(LPoints;LPoints;)LPoints;");
|
|
if (midROSEpp_plus == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_minus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pp_minus",
|
|
"(LPoints;LPoints;)LPoints;");
|
|
if (midROSEpp_minus == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_unequal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pp_unequal",
|
|
"(LPoints;LPoints;)Z");
|
|
if (midROSEpp_unequal == 0) error(__FILE__,__LINE__);
|
|
midROSEpp_intersection =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pp_intersection",
|
|
"(LPoints;LPoints;)LPoints;");
|
|
if (midROSEpp_intersection == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEll_border_in_common =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_border_in_common",
|
|
"(LLines;LLines;)Z");
|
|
if (midROSEll_border_in_common == 0) error(__FILE__,__LINE__);
|
|
midROSEll_common_border =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_common_border",
|
|
"(LLines;LLines;)LLines;");
|
|
if (midROSEll_common_border == 0) error(__FILE__,__LINE__);
|
|
midROSEll_disjoint =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_disjoint",
|
|
"(LLines;LLines;)Z");
|
|
if (midROSEll_disjoint == 0) error(__FILE__,__LINE__);
|
|
midROSEll_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_dist",
|
|
"(LLines;LLines;)Ltwodsack/util/number/Rational;");
|
|
if (midROSEll_dist == 0) error(__FILE__,__LINE__);
|
|
midROSEll_equal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"ll_equal","(LLines;LLines;)Z");
|
|
if (midROSEll_equal == 0) error(__FILE__,__LINE__);
|
|
midROSEll_intersection =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_intersection",
|
|
"(LLines;LLines;)LPoints;");
|
|
if (midROSEll_intersection == 0) error(__FILE__,__LINE__);
|
|
midROSEll_intersects =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"ll_intersects",
|
|
"(LLines;LLines;)Z");
|
|
if (midROSEll_intersects == 0) error(__FILE__,__LINE__);
|
|
midROSEll_meets =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"ll_meets","(LLines;LLines;)Z");
|
|
if (midROSEll_meets == 0) error(__FILE__,__LINE__);
|
|
midROSEll_minus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"ll_minus","(LLines;LLines;)LLines;");
|
|
if (midROSEll_minus == 0) error(__FILE__,__LINE__);
|
|
midROSEll_plus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"ll_plus","(LLines;LLines;)LLines;");
|
|
if (midROSEll_plus == 0) error(__FILE__,__LINE__);
|
|
midROSEll_unequal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,"ll_unequal","(LLines;LLines;)Z");
|
|
if (midROSEll_unequal == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSErr_adjacent =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_adjacent",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_adjacent == 0) error(__FILE__,__LINE__);
|
|
midROSErr_area_disjoint =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_area_disjoint",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_area_disjoint == 0) error(__FILE__,__LINE__);
|
|
midROSErr_border_in_common =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_border_in_common",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_border_in_common == 0) error(__FILE__,__LINE__);
|
|
midROSErr_common_border =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_common_border",
|
|
"(LRegions;LRegions;)LLines;");
|
|
if (midROSErr_common_border == 0) error(__FILE__,__LINE__);
|
|
midROSErr_disjoint =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_disjoint",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_disjoint == 0) error(__FILE__,__LINE__);
|
|
midROSErr_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_dist",
|
|
"(LRegions;LRegions;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSErr_dist == 0) error(__FILE__,__LINE__);
|
|
midROSErr_edge_disjoint =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_edge_disjoint",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_edge_disjoint == 0) error(__FILE__,__LINE__);
|
|
midROSErr_edge_inside =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_edge_inside",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_edge_inside == 0) error(__FILE__,__LINE__);
|
|
midROSErr_encloses =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_encloses",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_encloses == 0) error(__FILE__,__LINE__);
|
|
midROSErr_equal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_equal",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_equal == 0) error(__FILE__,__LINE__);
|
|
midROSErr_inside =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_inside",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_inside == 0) error(__FILE__,__LINE__);
|
|
midROSErr_intersection =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_intersection",
|
|
"(LRegions;LRegions;)LRegions;");
|
|
if (midROSErr_intersection == 0) error(__FILE__,__LINE__);
|
|
midROSErr_intersects =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_intersects",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_intersects == 0) error(__FILE__,__LINE__);
|
|
midROSErr_meets =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_meets",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_meets == 0) error(__FILE__,__LINE__);
|
|
midROSErr_minus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_minus",
|
|
"(LRegions;LRegions;)LRegions;");
|
|
if (midROSErr_minus == 0) error(__FILE__, __LINE__);
|
|
midROSErr_plus =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_plus",
|
|
"(LRegions;LRegions;)LRegions;");
|
|
if (midROSErr_plus == 0) error(__FILE__,__LINE__);
|
|
midROSErr_unequal =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_unequal",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_unequal == 0) error(__FILE__,__LINE__);
|
|
midROSErr_vertex_inside =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rr_vertex_inside",
|
|
"(LRegions;LRegions;)Z");
|
|
if (midROSErr_vertex_inside == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEpl_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pl_dist",
|
|
"(LPoints;LLines;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSEpl_dist == 0) error(__FILE__,__LINE__);
|
|
midROSEpl_on_border_of =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pl_on_border_of",
|
|
"(LPoints;LLines;)Z");
|
|
if (midROSEpl_on_border_of == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSEpr_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pr_dist",
|
|
"(LPoints;LRegions;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSEpr_dist == 0) error(__FILE__,__LINE__);
|
|
midROSEpr_inside =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pr_inside",
|
|
"(LPoints;LRegions;)Z");
|
|
if (midROSEpr_inside == 0) error(__FILE__,__LINE__);
|
|
midROSEpr_on_border_of =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"pr_on_border_of",
|
|
"(LPoints;LRegions;)Z");
|
|
if (midROSEpr_on_border_of == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSElp_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lp_dist",
|
|
"(LLines;LPoints;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSElp_dist == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSErp_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rp_dist",
|
|
"(LRegions;LPoints;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSErp_dist == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSElr_border_in_common =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_border_in_common",
|
|
"(LLines;LRegions;)Z");
|
|
if (midROSElr_border_in_common == 0) error(__FILE__,__LINE__);
|
|
midROSElr_common_border =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_common_border",
|
|
"(LLines;LRegions;)LLines;");
|
|
if (midROSElr_common_border == 0) error(__FILE__,__LINE__);
|
|
midROSElr_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_dist",
|
|
"(LLines;LRegions;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSElr_dist == 0) error(__FILE__,__LINE__);
|
|
midROSElr_inside =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_inside",
|
|
"(LLines;LRegions;)Z");
|
|
if (midROSElr_inside == 0) error(__FILE__,__LINE__);
|
|
midROSElr_intersects =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_intersects",
|
|
"(LLines;LRegions;)Z");
|
|
if (midROSElr_intersects == 0) error(__FILE__,__LINE__);
|
|
midROSElr_meets =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"lr_meets",
|
|
"(LLines;LRegions;)Z");
|
|
if (midROSElr_meets == 0) error(__FILE__,__LINE__);
|
|
|
|
midROSErl_border_in_common =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_border_in_common",
|
|
"(LRegions;LLines;)Z");
|
|
if (midROSErl_border_in_common == 0) error(__FILE__,__LINE__);
|
|
midROSErl_common_border =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_common_border",
|
|
"(LRegions;LLines;)LLines;");
|
|
if (midROSErl_common_border == 0) error(__FILE__,__LINE__);
|
|
midROSErl_dist =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_dist",
|
|
"(LRegions;LLines;)"
|
|
"Ltwodsack/util/number/Rational;");
|
|
if (midROSErl_dist == 0) error(__FILE__,__LINE__);
|
|
midROSErl_intersection =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_intersection",
|
|
"(LRegions;LLines;)LLines;");
|
|
if (midROSErl_intersection == 0) error(__FILE__,__LINE__);
|
|
midROSErl_intersects =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_intersects",
|
|
"(LRegions;LLines;)Z");
|
|
if (midROSErl_intersects == 0) error(__FILE__,__LINE__);
|
|
midROSErl_meets =
|
|
env->GetStaticMethodID(clsROSEAlgebra,
|
|
"rl_meets",
|
|
"(LRegions;LLines;)Z");
|
|
if (midROSErl_meets == 0) error(__FILE__,__LINE__);
|
|
|
|
//define java fields, that are needed
|
|
fidRationalX =
|
|
env->GetFieldID(clsPoint, "x", "Ltwodsack/util/number/Rational;");
|
|
if (fidRationalX == 0) error(__FILE__,__LINE__);
|
|
fidRationalY =
|
|
env->GetFieldID(clsPoint, "y", "Ltwodsack/util/number/Rational;");
|
|
if (fidRationalY == 0) error(__FILE__,__LINE__);
|
|
fidPointsPointSet =
|
|
env->GetFieldID(clsPoints, "pointset", "Ltwodsack/set/PointMultiSet;");
|
|
if (fidPointsPointSet == 0) error(__FILE__,__LINE__);
|
|
fidLinesSegmentSet =
|
|
env->GetFieldID(clsLines, "segset", "Ltwodsack/set/SegMultiSet;");
|
|
if (fidLinesSegmentSet == 0) error(__FILE__,__LINE__);
|
|
|
|
clsRoseError = env->FindClass("RoseAlgebraError");
|
|
if (clsRoseError == 0) error(__FILE__,__LINE__);
|
|
fidROSEError =
|
|
env->GetFieldID(clsRoseError, "errorMessage", "Ljava/lang/String;");
|
|
if (fidROSEError == 0) error(__FILE__,__LINE__);
|
|
|
|
|
|
nl = nlRef;
|
|
qp = qpRef;
|
|
|
|
return (new RoseAlgebra());
|
|
}
|