Interface margins and axes bounds properties.
Jean-baptiste Silvy [Tue, 3 Jul 2007 13:48:38 +0000 (13:48 +0000)]
31 files changed:
scilab/modules/graphics/includes/GetProperty.h
scilab/modules/graphics/includes/SetProperty.h
scilab/modules/graphics/includes/math_graphics.h
scilab/modules/graphics/src/c/BuildObjects.c
scilab/modules/graphics/src/c/GetProperty.c
scilab/modules/graphics/src/c/SetProperty.c
scilab/modules/graphics/src/c/getHandleProperty/get_data_bounds_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_bounds_property.c
scilab/modules/graphics/src/c/math_graphics.c
scilab/modules/jvm/includes/JniUtils.h
scilab/modules/jvm/src/c/JniUtils.c
scilab/modules/renderer/graphics_Import.def
scilab/modules/renderer/includes/DrawingBridge.h
scilab/modules/renderer/renderer.vcproj
scilab/modules/renderer/renderer_header.def
scilab/modules/renderer/src/cpp/DrawableObjectJoGL.cpp
scilab/modules/renderer/src/cpp/DrawingBridge.cpp
scilab/modules/renderer/src/cpp/figureDrawing/DrawableFigureJoGL.cpp
scilab/modules/renderer/src/cpp/figureDrawing/FigureScilabCall.cpp
scilab/modules/renderer/src/cpp/rectangleDrawing/DrawableRectangle.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/Camera.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/Camera.h
scilab/modules/renderer/src/cpp/subwinDrawing/CameraBridge.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/CameraBridge.h
scilab/modules/renderer/src/cpp/subwinDrawing/CameraJoGL.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/DrawableSubwin.cpp
scilab/modules/renderer/src/cpp/subwinDrawing/DrawableSubwin.h
scilab/modules/renderer/src/cpp/subwinDrawing/DrawableSubwinFactory.cpp
scilab/modules/renderer/src/java/org/scilab/modules/renderer/figureDrawing/DrawableFigureJoGL.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/figureDrawing/SciRenderer.java
scilab/modules/renderer/src/java/org/scilab/modules/renderer/subwinDrawing/CameraJoGL.java

index 92efbb7..b6d88cd 100644 (file)
@@ -210,4 +210,7 @@ double * sciGetMargins( sciPointObj * pObj ) ;
 
 BOOL sciGetIsReadyForRendering( sciPointObj * pobj ) ; /* GET */
 
+void sciGetRealDataBounds( sciPointObj * pObj, double bounds[6] ) ; /* GET */
+void sciGetDataBounds( sciPointObj * pObj, double bounds[6] ) ; /* GET */
+
 #endif /* __SCI_GET_PROPERTY__ */
index 86db61d..742c6bc 100644 (file)
@@ -20,7 +20,6 @@
 
 #include "ObjectStructure.h"
 #include "HandleManagement.h"
-/* #include "GraphicGlobals.h" */
 
 
 #ifndef __SCI_SET_PROPERTY__
@@ -249,6 +248,8 @@ int sciSetSelectedObject( sciPointObj * pObj ) ;
 
 int sciInitIsReadyForRendering( sciPointObj * pObj, BOOL isReady ) ;
 
+int sciSetDataBounds( sciPointObj * pObj, double bounds[6] ) ; /* SET */
+
 /*---------------------------------------------------------------------------*/
 /* return 0 if the string contains any % character, 1 if a %d has been found */
 /* and -1 otherwise. */
index d306e95..7bcc484 100644 (file)
 #define                round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
 #define EPSILON 1.0e-13
 
-
-
-/** 
-  #define linint(x) ((integer) floor(x)) 
-  #define inint(x) ((int) floor(x))  
-**/
-
-/** 
-  if we suppose that the x transmited is in the range of integers 
-  we could also use :
-  #define inint(x) (( x > 0 ) ? ((int) (x + 0.5)) : ((int) (x - 0.5));
- **/
-
 #define linint(x) ((integer) floor(x + 0.5 )) 
 #define inint(x) ((int) floor(x + 0.5 ))  
 
@@ -109,6 +96,9 @@ extern double exp10 __PARAMS((double));
 /* prototypes */
 
 /*----------------------------------------------------------------------------*/
+/************************************************************************/
+/* 2D algorithms                                                        */
+/************************************************************************/
 /* perform the rotation of point from to point dest with angle in radian  */
 void rotate2D( double from[2], double center[2], double angle, double dest[2] ) ;
 
@@ -161,6 +151,25 @@ void iNormalize2d( int vect[2] ) ;
  */
 #define DOT_PROD_2D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) )
 
+/**
+ * Norm of a 2D vector
+ */
+#define NORM_2D(v) ( sqrt( DOT_PROD_2D((v),(v)) ) ) ;
+
+/************************************************************************/
+/* 3D algorithms                                                        */
+/************************************************************************/
+
+/**
+ * Scalar product of 2 vectors in 3D
+ */
+#define DOT_PROD_3D(v1,v2) ( ((v1)[0]) * ((v2)[0]) + ((v1)[1]) * ((v2)[1]) + ((v1)[2]) * ((v2)[2]) )
+
+/**
+* Norm of a 3D vector
+*/
+#define NORM_3D(v) ( sqrt( DOT_PROD_3D((v),(v)) ) ) ;
+
 /*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
@@ -177,19 +186,19 @@ int safeEqual( double val1, double val2, double accuracy ) ;
 /*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
-/* truncate an integer to a 16 bits integer. Overflow value are trucated to the min */
+/* truncate an integer to a 16 bits integer. Overflow value are truncated to the min */
 /* and max of 16 bits integer. */
 #define INT_2_16B(i) ( (i) > INT16MAX ? (INT16MAX) : ( (i) < INT16MIN ? INT16MIN : ((SCIINT16) i)) )
 /*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
-/* truncate an integer to a char. Overflow value are trucated to the min */
+/* truncate an integer to a char. Overflow value are truncated to the min */
 /* and max of char integer. */
 #define INT_2_UCHAR(i) ( (i) > UCHAR_MAX ? (UCHAR_MAX) : ( (i) < 0  ? 0 : ((char) i)) )
 /*----------------------------------------------------------------------------*/
 
 /*----------------------------------------------------------------------------*/
-/* truncate a float or double to an int. Overflow value are trucated to the min */
+/* truncate a float or double to an int. Overflow value are truncated to the min */
 /* and max of 32 bits integer. */
 #define FLOAT_2_INT(f) ( (f) > INT_MAX ? (INT_MAX) : ( (f) < INT_MIN ? (INT_MIN) : ( inint( f ) ) ) )
 /*----------------------------------------------------------------------------*/
index c8043a8..672cfca 100644 (file)
@@ -38,6 +38,7 @@
 #include "CurrentObjectsManagement.h"
 #include "ObjectSelection.h"
 #include "BuildDrawingObserver.h"
+#include "DrawingBridge.h"
 
 #include "MALLOC.h" /* MALLOC */
 
@@ -2877,6 +2878,7 @@ sciPointObj * sciStandardBuildOperations( sciPointObj * pObj, sciPointObj * pare
   
 
   pObj->pDrawer = NULL ;
+  //createDrawer(pObj) ;
 
   return pObj ;
 
index e520aa2..336b2ba 100644 (file)
@@ -5177,3 +5177,62 @@ BOOL sciGetIsReadyForRendering( sciPointObj * pobj )
   return NULL ;
 }
 /*-------------------------------------------------------------------------------------------*/
+/**
+ * To get the computed data bounds of a subwin.
+ * * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
+ */
+void sciGetRealDataBounds( sciPointObj * pObj, double bounds[6] )
+{
+  int i;
+  switch( sciGetEntityType(pObj) )
+  {
+  case SCI_SUBWIN:
+    /* from history it is stored [xmin,ymin,xmax,ymax,zmin,zmax] */
+    bounds[0] = pSUBWIN_FEATURE(pObj)->FRect[0] ;
+    bounds[1] = pSUBWIN_FEATURE(pObj)->FRect[2] ;
+    bounds[2] = pSUBWIN_FEATURE(pObj)->FRect[1] ;
+    bounds[3] = pSUBWIN_FEATURE(pObj)->FRect[3] ;
+    bounds[4] = pSUBWIN_FEATURE(pObj)->FRect[4] ;
+    bounds[5] = pSUBWIN_FEATURE(pObj)->FRect[5] ;
+    return ;
+  default:
+    sciprint("This object has computed no data bounds.\n");
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      bounds[i] = 0.0 ;
+    } 
+  }
+  return ;
+}
+/*-------------------------------------------------------------------------------------------*/
+/**
+ * Get data-bounds defined by the user and not modified for pretty print by scilab.
+ * * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
+ */
+void sciGetDataBounds( sciPointObj * pObj, double bounds[6] )
+{
+  int i;
+  switch( sciGetEntityType(pObj) )
+  {
+  case SCI_SUBWIN:
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      bounds[i] = pSUBWIN_FEATURE(pObj)->SRect[i] ;
+    }
+    return ;
+  case SCI_SURFACE:
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      bounds[i] = pSURFACE_FEATURE(pObj)->ebox[i] ;
+    }
+    return ;
+  default:
+    sciprint("This object has no data bounds.\n");
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      bounds[i] = 0.0 ;
+    } 
+  }
+  return ;
+}
+/*-------------------------------------------------------------------------------------------*/
index 8bbc27f..82b174a 100644 (file)
@@ -4908,4 +4908,40 @@ int sciInitIsReadyForRendering( sciPointObj * pObj, BOOL isReady )
   }
   return 0 ;
 }
-/*--------------------------------------------------------------------------------------------*/
\ No newline at end of file
+/*--------------------------------------------------------------------------------------------*/
+/**
+ * Set data-bounds defined by the user.
+ * @param bounds [Xmin,Xmax,Ymain,Ymax,Zmin,Zmax] vector.
+ */
+int sciSetDataBounds( sciPointObj * pObj, double bounds[6] )
+{
+  int i;
+  switch( sciGetEntityType(pObj) )
+  {
+  case SCI_SUBWIN:
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      pSUBWIN_FEATURE(pObj)->SRect[i] = bounds[i] ;
+    }
+    /* Temporary */
+    pSUBWIN_FEATURE(pObj)->FRect[0] = bounds[0];
+    pSUBWIN_FEATURE(pObj)->FRect[1] = bounds[2];
+    pSUBWIN_FEATURE(pObj)->FRect[2] = bounds[1];
+    pSUBWIN_FEATURE(pObj)->FRect[3] = bounds[3];
+    pSUBWIN_FEATURE(pObj)->FRect[4] = bounds[4];
+    pSUBWIN_FEATURE(pObj)->FRect[5] = bounds[5];
+    break ;
+  case SCI_SURFACE:
+    for ( i = 0 ; i < 6 ; i++ )
+    {
+      pSURFACE_FEATURE(pObj)->ebox[i] = bounds[i] ;
+    }
+    break;
+  default:
+    sciprint("This object has no data bounds.\n");
+    return -1 ; 
+
+  }
+  return 0 ;
+}
+/*--------------------------------------------------------------------------------------------*/
index dd9b1b7..e4f9e3b 100644 (file)
 int get_data_bounds_property( sciPointObj * pobj )
 {
 
+  double bounds[6] ;
+  sciGetDataBounds(pobj, bounds) ;
+
   if ( sciGetEntityType(pobj) == SCI_SUBWIN )
   {
     /**DJ.Abdemouche 2003**/
     if ( sciGetIs3d( pobj ) )
     {
-      return sciReturnMatrix( pSUBWIN_FEATURE (pobj)->SRect, 2, 3 ) ;
+      return sciReturnMatrix( bounds, 2, 3 ) ;
     }
     else
     {
-      return sciReturnMatrix( pSUBWIN_FEATURE (pobj)->SRect, 2, 2 ) ;
+      return sciReturnMatrix( bounds, 2, 2 ) ;
     }
   }
   else if ( sciGetEntityType (pobj) == SCI_SURFACE )
   {
     /* used for what ? F.Leray 20.04.05 */
-    return sciReturnMatrix( pSURFACE_FEATURE (pobj)->ebox, 3, 2 ) ;
+    return sciReturnMatrix( bounds, 3, 2 ) ;
   }
   else
   {
index 8f0fcbc..1486405 100644 (file)
@@ -182,20 +182,24 @@ int set_data_bounds_property( sciPointObj * pobj, int stackPointer, int valueTyp
     if ( nbRow * nbCol == 4 )
     { 
       /* 2D */
-      ppSubWin->SRect[0] = xMin ;
-      ppSubWin->SRect[1] = xMax ;
-      ppSubWin->SRect[2] = yMin ;
-      ppSubWin->SRect[3] = yMax ;
+      double bounds[6];
+      
+      /* To get the Z coordinates */
+      sciGetDataBounds(pobj, bounds) ;
+      bounds[0] = xMin ;
+      bounds[1] = xMax ;
+      bounds[2] = yMin ;
+      bounds[3] = yMax ;
+
+      sciSetDataBounds(pobj, bounds) ;
     }
     else
     {
       /* 3D */
-      ppSubWin->SRect[0] = xMin ;
-      ppSubWin->SRect[1] = xMax ;
-      ppSubWin->SRect[2] = yMin ;
-      ppSubWin->SRect[3] = yMax ;
-      ppSubWin->SRect[4] = zMin ;
-      ppSubWin->SRect[5] = zMax ;
+      double bounds[6] = {xMin, xMax, yMin, yMax, zMin, zMax} ;
+      
+      sciSetDataBounds(pobj, bounds) ;
+      
     }
 
     ppSubWin->FirstPlot = FALSE;
@@ -209,8 +213,7 @@ int set_data_bounds_property( sciPointObj * pobj, int stackPointer, int valueTyp
       sciprint( "Second argument must have 6 elements.\n" ) ;
       return SET_PROPERTY_ERROR ;
     }
-
-    copyDoubleVectorFromStack( stackPointer, pSURFACE_FEATURE(pobj)->ebox, 6 ) ;
+    sciSetDataBounds(pobj, getDoubleMatrixFromStack(stackPointer) ) ;
 
     return SET_PROPERTY_SUCCEED ;
   }
index d32bab4..ebbce77 100644 (file)
@@ -129,14 +129,14 @@ void iTranslate2D( int from[2], int trans[2], int dest[2] )
 /*----------------------------------------------------------------------------*/
 void normalize2d( double vect[2] )
 {
-  double norm = sqrt( vect[0] * vect[0] + vect[1] * vect[1] ) ;
+  double norm = NORM_2D(vect) ;
   vect[0] /= norm ;
   vect[1] /= norm ;
 }
 /*----------------------------------------------------------------------------*/
 void iNormalize2d( int vect[2] )
 {
-  double norm = sqrt( vect[0] * vect[0] + vect[1] * vect[1] ) ;
+  double norm = NORM_2D(vect) ;
   vect[0] = round( vect[0] / norm ) ;
   vect[1] = round( vect[1] / norm ) ;
 }
index 729628e..c47f4a5 100644 (file)
@@ -35,7 +35,7 @@ void jniDestroyCallMethodCache( jniCallMethodCache * cache ) ;
 /**
  * Initialize a cache with its values.
  */
-void jniIntializeCallMethodCache( jniCallMethodCache * cache, jclass instanceClass, jmethodID methodId ) ;
+void jniInitializeCallMethodCache( jniCallMethodCache * cache, jclass instanceClass, jmethodID methodId ) ;
 
 /**
  * To know if a cache has alredy been initialized
@@ -68,7 +68,7 @@ void jniSetCurrentEnv( JNIEnv * env ) ;
  * This function should be called each time the environment
  * May have changed.
  */
-void jniUpdateCurrentEnv( void ) ;
+JNIEnv * jniUpdateCurrentEnv( void ) ;
 
 /**
  * Get the current Java environment
@@ -114,23 +114,10 @@ BOOL jniCreateDefaultInstance(     const char * className, jclass * instanceClas
 BOOL jniCreateDefaultInstanceSafe( const char * className, jclass * instanceClass, jobject * instance ) ;
 
 /**
- * Call a Java function returning void.
- * @param instance Object caontaining the function to call
- * @param functionName Name of the function
- * @param paramTypes string containing the types of paramaters given as optionals argument.
- *                   This respect the JNI style and looks like "[DID".
- * @return TRUE if the call was succesful, FALSE otherwise.
- */
-BOOL jniCallVoidFunction(     jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, ... ) ;
-BOOL jniCallVoidFunctionSafe( jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, ... ) ;
-BOOL jniCallVoidFunctionV(    jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, va_list args ) ;
-
-/**
  * Call a java member function from C code.
- * @param instance bject containing the function to call
+ * @param instance object containing the function to call
  * @param cache cache relative to this function used to speed up call to the function.
  *              if cache is NULL, then it is not used. If cache is not initialized then the function will initialize it.
- * @param pointer on the instance class. If NULL the class would be retrieved from the object and stored in the instance class.
  * @param functionName Name of the function
  * @param descriptor string containing the kinds of parameters the function takes and the return type.
  *                   This respect the JNI style and looks like "([DID)V".
index 9c7aeb2..802a30a 100644 (file)
@@ -43,7 +43,7 @@ void jniDestroyCallMethodCache( jniCallMethodCache * cache )
   }
 }
 /*------------------------------------------------------------------------------------------*/
-void jniIntializeCallMethodCache( jniCallMethodCache * cache, jclass instanceClass, jmethodID methodId )
+void jniInitializeCallMethodCache( jniCallMethodCache * cache, jclass instanceClass, jmethodID methodId )
 {
   cache->methodId = methodId ;
 
@@ -72,13 +72,14 @@ void jniSetCurrentEnv( JNIEnv * env )
   sciJEnv = env ;
 }
 /*------------------------------------------------------------------------------------------*/
-void jniUpdateCurrentEnv( void )
+JNIEnv * jniUpdateCurrentEnv( void )
 {
   /* tips from sun, use AttachCurrentThread to always get the right environment */ 
   (*sciJVM)->AttachCurrentThread( sciJVM, (void **) &sciJEnv, NULL ) ;
   //(*sciJVM)->GetEnv( sciJVM, (void **) &sciJEnv, JNI_VERSION_1_6 ) ;
   /* clear all previous exceptions pending on the thread */
   (*sciJEnv)->ExceptionClear( sciJEnv ) ;
+  return sciJEnv;
 }
 /*------------------------------------------------------------------------------------------*/
 JNIEnv * jniGetCurrentJavaEnv( void )
@@ -163,9 +164,6 @@ BOOL jniCreateDefaultInstance( const char * className, jclass * instanceClass, j
 
   *instanceClass = (*sciJEnv)->NewGlobalRef(sciJEnv, localClass) ;
 
-  (*sciJEnv)->DeleteLocalRef(sciJEnv, localClass) ;
-  localClass = NULL ;
-
   /* "()V" for no parameters and return void */
   /* "<init>" for constructor */
   constructObject = (*sciJEnv)->GetMethodID( sciJEnv, *instanceClass, "<init>", "()V" ) ;
@@ -181,8 +179,6 @@ BOOL jniCreateDefaultInstance( const char * className, jclass * instanceClass, j
   }
   
   *instance = (*sciJEnv)->NewGlobalRef(sciJEnv, localInstance) ;
-  (*sciJEnv)->DeleteLocalRef(sciJEnv, localInstance) ;
-  localInstance = NULL;
 
   return TRUE ;
 }
@@ -194,69 +190,6 @@ BOOL jniCreateDefaultInstanceSafe( const char * className, jclass * instanceClas
   return jniCreateDefaultInstance( className, instanceClass, instance ) ;
 }
 /*------------------------------------------------------------------------------------------*/
-BOOL jniCallVoidFunctionV( jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, va_list args )
-{
-  jmethodID   voidMethod = NULL ;
-  jclass      instanceClasse = (*sciJEnv)->GetObjectClass( sciJEnv, instance ) ; /* retrieve the class of the object */
-  char      * callingSequence = NULL ;
-
-  /* Add (...)V around the paramList */
-  callingSequence = MALLOC( ( strlen(paramTypes) + 4 ) * sizeof(char) ) ; /* 3 for ()V and 1 for 0 terminating character */
-  if ( callingSequence == NULL ) { return FALSE ; }
-
-  sprintf( callingSequence, "(%s)V", paramTypes ) ;
-
-  /* Find the method in the class */
-  voidMethod = (*sciJEnv)->GetMethodID( sciJEnv, instanceClass, functionName, callingSequence ) ;
-  if ( !jniCheckLastCall(TRUE) || voidMethod == NULL )
-  {
-    Scierror( 999, "Unable to find method %s.\r\n", functionName ) ;
-    FREE( callingSequence ) ;
-    return FALSE ;
-  }
-
-  /* Call the function with the optionals parameters */
-  (*sciJEnv)->CallVoidMethodV( sciJEnv, instance, voidMethod, args ) ;
-  if ( !jniCheckLastCall(TRUE) )
-  {
-    Scierror( 999, "Error when calling method %s.\r\n", functionName ) ;
-    FREE( callingSequence ) ;
-    return FALSE ;
-  }
-
-  //(*sciJEnv)->DeleteLocalRef(sciJEnv, instanceClass) ;
-  FREE( callingSequence ) ;
-  return TRUE ;
-}
-/*------------------------------------------------------------------------------------------*/
-BOOL jniCallVoidFunction( jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, ... )
-{
-  BOOL status = FALSE ;
-  va_list args ;
-  va_start( args, paramTypes ) ;
-  status = jniCallVoidFunctionV( instance, instanceClass, functionName, paramTypes, args ) ;
-  va_end(args);
-  
-  return status ;
-}
-/*------------------------------------------------------------------------------------------*/
-BOOL jniCallVoidFunctionSafe( jobject instance, jclass instanceClass, const char * functionName, const char * paramTypes, ... )
-{
-  va_list args ;
-  BOOL status = FALSE ;
-
-  if ( instance == NULL ) { return FALSE ; }
-
-  jniUpdateCurrentEnv() ;
-
-  /* Call the function with the optionals parameters */
-  va_start( args, paramTypes ) ;
-  status = jniCallVoidFunctionV( instance, instanceClass, functionName, paramTypes, args ) ;
-  va_end(args);
-  return status ;
-
-}
-/*------------------------------------------------------------------------------------------*/
 jvalue jniCallMemberFunction( jobject instance, jniCallMethodCache * cache, const char * functionName, const char * descriptor, ... )
 {
   va_list args ;
@@ -305,7 +238,7 @@ jvalue jniCallMemberFunctionV( jobject instance, jniCallMethodCache * cache, con
       methodId = (*sciJEnv)->GetMethodID(sciJEnv, instanceClass, functionName, descriptor ) ;
       if ( cache != NULL )
       {
-        jniIntializeCallMethodCache(cache, instanceClass, methodId) ;
+        jniInitializeCallMethodCache(cache, instanceClass, methodId) ;
       }
     }
     else
index 73d9d96..58f2250 100644 (file)
@@ -42,3 +42,4 @@ sciGetAxesBounds
 sciGetMargins
 doubleArrayCopy
 sciGetIsReadyForRendering
+sciGetRealDataBounds
\ No newline at end of file
index 6783961..d57ab49 100644 (file)
@@ -15,6 +15,11 @@ extern "C" {
 #include "../../../graphics/includes/ObjectStructure.h"
 
   /**
+   * Create a render for this object
+   */
+  void createDrawer( sciPointObj * pObj ) ;
+
+  /**
    * Delete the drawer of a graphic handle
    */
   void destroyHandleDrawer( sciPointObj * pObj ) ;
index d9a8d34..70f796a 100644 (file)
                                >
                        </File>
                        <File
-                               RelativePath=".\src\cpp\DrawingBridge.h"
+                               RelativePath=".\includes\DrawingBridge.h"
                                >
                        </File>
                        <File
index 1e6d12c..da89376 100644 (file)
@@ -17,5 +17,6 @@ Java_org_scilab_modules_renderer_figureDrawing_FigureScilabCall_displayFigure
 Java_org_scilab_modules_renderer_figureDrawing_FigureScilabCall_redrawFigure
 sciSetJavaColormap
 sciGetJavaColormap
+createDrawer
 ; --------------------------------------- 
 
index ede0550..2cb229c 100644 (file)
@@ -59,7 +59,7 @@ void DrawableObjectJoGL::destroy( void )
   if ( m_oDrawableObject != NULL )
   {
     jniCallMemberFunctionSafe( m_oDrawableObject, NULL, "destroy", "(I)V", sciGetNum(sciGetParentFigure(m_pDrawer->getDrawedObject())) ) ;
-    jniDeleteGlobalEntity( m_oDrawableObject ) ;
+    jniDeleteGlobalEntity(m_oDrawableObject) ;
     jniDeleteGlobalEntity(m_oDrawableClass) ;
   }
   m_oDrawableObject = NULL ;
index 8109289..810e882 100644 (file)
@@ -17,6 +17,11 @@ extern "C"
 using namespace sciGraphics ;
 
 /*------------------------------------------------------------------------------------------*/
+void createDrawer( sciPointObj * pObj )
+{
+  getHandleDrawer( pObj ) ;
+}
+/*------------------------------------------------------------------------------------------*/
 void destroyHandleDrawer( sciPointObj * pObj )
 {
   /* don't call getHandleDrawer for the test, otherwise a drawer will be created */
index 3fa2485..75efb19 100644 (file)
@@ -38,12 +38,16 @@ DrawableFigureJoGL::~DrawableFigureJoGL( void )
 void DrawableFigureJoGL::drawCanvas( void )
 {
   // We call the display function to be sure to be in the right context
+  jniUpdateCurrentEnv();
   jniCallMemberFunctionSafe( m_oDrawableObject, NULL, "display", "()V" ) ;
+  jniUpdateCurrentEnv();
 }
 /*------------------------------------------------------------------------------------------*/
 void DrawableFigureJoGL::openRenderingCanvas( int figureIndex )
 {
+  jniUpdateCurrentEnv();
   jniCallMemberFunctionSafe( m_oDrawableObject, NULL, "openRenderingCanvas", "(I)V", figureIndex ) ;
+  jniUpdateCurrentEnv();
 }
 /*------------------------------------------------------------------------------------------*/
 void DrawableFigureJoGL::closeRenderingCanvas( void )
index fbb385e..2109fb7 100644 (file)
@@ -22,6 +22,7 @@ JNIEXPORT void JNICALL Java_org_scilab_modules_renderer_figureDrawing_FigureScil
   int figIndex = (int) figureId ;
   sciPointObj * curFig = sciIsExistingFigure(&figIndex) ;
   if ( curFig == NULL ) { return ;}
+  jniSetCurrentEnv(env) ; // we are in a new thread
   if ( sciGetIsReadyForRendering(curFig) )
   {
     (sciGraphics::getFigureDrawer(curFig))->drawInContext() ;
@@ -35,6 +36,7 @@ JNIEXPORT void JNICALL Java_org_scilab_modules_renderer_figureDrawing_FigureScil
   int figIndex = (int) figureId ;
   sciPointObj * curFig = sciIsExistingFigure(&figIndex) ;
   if ( curFig == NULL ) { return ;}
+  jniSetCurrentEnv(env) ; // we are in a new thread
   if ( sciGetIsReadyForRendering(curFig) )
   {
     redrawHierarchy(curFig) ;
index 04355b1..59dc36c 100644 (file)
@@ -59,11 +59,11 @@ void DrawableRectangle::getCornersCoordinates( double corner1[3], double corner2
   corner1[2] = ppRect->z ;
 
   corner2[0] = ppRect->x ;
-  corner2[1] = ppRect->y + ppRect->height ;
+  corner2[1] = ppRect->y - ppRect->height ;
   corner2[2] = ppRect->z ;
 
   corner3[0] = ppRect->x + ppRect->width  ;
-  corner3[1] = ppRect->y + ppRect->height ;
+  corner3[1] = ppRect->y - ppRect->height ;
   corner3[2] = ppRect->z ;
 
   corner4[0] = ppRect->x + ppRect->width ;
index 1143db1..d4a345b 100644 (file)
@@ -44,12 +44,29 @@ void Camera::setViewingArea( double axesBounds[4], double margins[4] )
 /*-----------------------------------------------------------------------------------*/
 void Camera::setRotationAngles( double alpha, double theta )
 {
-  m_pImp->setRotationAngles(alpha, theta);
+  m_dAlpha = alpha ;
+  m_dTheta = theta ;
 }
 /*-----------------------------------------------------------------------------------*/
-void Camera::setSubWinBox( double box[6] )
+void Camera::setSubwinBox( double bounds[6] )
 {
-  m_pImp->setSubWinBox(box);
+  for ( int i = 0 ; i < 6 ; i++ )
+  {
+    m_aAxesBox[i] = bounds[i] ;
+  }
+  
+  double scale[3] ;
+  // 1.0 / ( Xmax - Xmin )
+  scale[0] = 1.0 / (bounds[1] - bounds[0]) ;
+  scale[1] = 1.0 / (bounds[3] - bounds[2]) ;
+  scale[2] = 1.0 / (bounds[5] - bounds[4]) ;
+  m_pImp->setAxesScale(scale) ;
+
+  double trans[3];
+  trans[0] = -bounds[0] ;
+  trans[1] = -bounds[2] ;
+  trans[2] = bounds[4] ;
+  m_pImp->setAxesTranslation(trans) ;
 }
 /*-----------------------------------------------------------------------------------*/
 void Camera::setFarthestDistance( double maxDist )
@@ -62,5 +79,14 @@ void Camera::renderPosition( void )
   m_pImp->renderPosition();
 }
 /*-----------------------------------------------------------------------------------*/
+void Camera::getSubwinCenter( double center[3] )
+{
+  // middle of the box
+  center[0] = (m_aAxesBox[0] + m_aAxesBox[1]) / 2.0 ;
+  center[1] = (m_aAxesBox[2] + m_aAxesBox[3]) / 2.0 ;
+  center[2] = (m_aAxesBox[4] + m_aAxesBox[5]) / 2.0 ;
+}
+/*-----------------------------------------------------------------------------------*/
+
 
 }
index 4638b67..1d28648 100644 (file)
@@ -38,8 +38,9 @@ public:
 
   /**
    * Specify the axes box to render.
+   * @param bounds [Xmin,Xmax,Ymin,Ymax,Zmin,Zmax] vector.
    */
-  void setSubWinBox( double box[6] ) ;
+  void setSubwinBox( double bounds[6] ) ;
 
   /**
    * Specify the farthest distance from the camera in order to specify zNear and zFar
@@ -58,9 +59,31 @@ public:
 
 protected:
 
+  /*-----------------------------------------------------*/
+  /**
+   * Get the center of the watched subwin.
+   */
+  void getSubwinCenter( double center[3] ) ;
+
+  /**
+   * Compute the eye position which will be able to wtch the whole subwin
+   */
+  void computeEyePosition( double eyePosition[3] ) ;
+  /*-----------------------------------------------------*/
+
   /** bridge for driver dependent algorithms */
   CameraBridge * m_pImp;
 
+  /** specify the axis box */
+  double m_aAxesBox[6];
+
+  /** Rotation angle around axe Z */
+  double m_dTheta;
+  /** Rotation around axe Y */
+  double m_dAlpha;
+
+  /*-----------------------------------------------------*/
+
 };
 
 }
index 76787f3..4b2c64d 100644 (file)
@@ -6,11 +6,6 @@
 /*------------------------------------------------------------------------*/
 
 #include "CameraBridge.h"
-extern "C"
-{
-#include "BasicAlgos.h"
-}
-
 
 namespace sciGraphics
 {
@@ -25,15 +20,18 @@ void CameraBridge::setViewingArea( double translation[2], double scale[2] )
   m_aViewingScale[1] = scale[1];
 }
 /*-----------------------------------------------------------------------------------*/
-void CameraBridge::setRotationAngles( double alpha, double theta )
+void CameraBridge::setAxesScale( double scale[3] )
 {
-  m_dTheta = theta ;
-  m_dAlpha = alpha ;
+  m_aAxesScale[0] = scale[0] ;
+  m_aAxesScale[1] = scale[1] ;
+  m_aAxesScale[2] = scale[2] ;
 }
 /*-----------------------------------------------------------------------------------*/
-void CameraBridge::setSubWinBox( double box[6] )
+void CameraBridge::setAxesTranslation( double translation[3] )
 {
-  doubleArrayCopy( m_aAxesBox, box, 6 );
+  m_aAxesTranslation[0] = translation[0] ;
+  m_aAxesTranslation[1] = translation[1] ;
+  m_aAxesTranslation[2] = translation[2] ;
 }
 /*-----------------------------------------------------------------------------------*/
 void CameraBridge::setFarthestDistance( double maxDist )
@@ -41,10 +39,4 @@ void CameraBridge::setFarthestDistance( double maxDist )
   m_dFarthestDist = maxDist;
 }
 /*-----------------------------------------------------------------------------------*/
-void CameraBridge::setAxesBox( double bbox[6] )
-{
-  doubleArrayCopy(m_aAxesBox, bbox, 6) ;
-}
-/*-----------------------------------------------------------------------------------*/
-
 }
index cdfb761..df90ccb 100644 (file)
@@ -31,14 +31,14 @@ public:
   void setViewingArea( double translation[2], double scale[2] ) ;
 
   /**
-  * Set the rotation angles of the camera.
+   * Set the scale to fit with the subwin data bounds
    */
-  void setRotationAngles( double alpha, double theta ) ;
+  void setAxesScale( double scale[3] ) ;
 
   /**
-   * Specify the axes box to render.
+   * Set the translation to put the axes into view
    */
-  void setSubWinBox( double box[6] ) ;
+  void setAxesTranslation( double translation[3] ) ;
 
   /**
    * Specify the farthest distance from the camera in order to specify zNear and zFar
@@ -46,11 +46,6 @@ public:
   void setFarthestDistance( double maxDist ) ;
 
   /**
-   *  Set the bouding box of axes (the one drawn on the screen)
-   */
-  void setAxesBox( double bbox[6] ) ;
-
-  /**
    * Position the view and view area accordingly to previous calls.
    */
   virtual void renderPosition( void ) = 0 ;
@@ -64,22 +59,20 @@ protected:
   double m_aViewingTranslation[2];
 
   /**
-  * Scaling between the rendering canvas and current viewing area.
-  * Should be lower than 1 since the viewing area is smaller than the canvas.
-  */
+   * Scaling between the rendering canvas and current viewing area.
+   * Should be lower than 1 since the viewing area is smaller than the canvas.
+   */
   double m_aViewingScale[2];
 
-  /** Rotation angle around axe Z */
-  double m_dTheta;
-  /** Rotation around axe Y */
-  double m_dAlpha;
-
-  /** specify the axis box */
-  double m_aAxesBox[6];
-
   /** maximum found distance between a graphic object and the viewpoint */
   double m_dFarthestDist;
 
+  /** Scale modification to fit axes coordinates */
+  double m_aAxesScale[3];
+
+  /** Translation to put the axes in view */
+  double m_aAxesTranslation[3];
+
 };
 
 }
index 6760501..ce4e316 100644 (file)
@@ -27,7 +27,12 @@ CameraJoGL::CameraJoGL( DrawableObject * subwin )
 void CameraJoGL::renderPosition( void )
 {
   initializeDrawing();
-  jniCallVoidFunctionSafe( m_oDrawableObject, m_oDrawableClass, "moveViewingArea", "");
+  jniCallMemberFunctionSafe( m_oDrawableObject, NULL, "moveViewingArea", "(DDDD)V",
+                             m_aViewingTranslation[0], m_aViewingTranslation[1],
+                             m_aViewingScale[0], m_aViewingScale[1] ) ;
+  jniCallMemberFunctionSafe(m_oDrawableObject, NULL, "moveAxesBox", "(DDDDDD)V",
+                            m_aAxesScale[0], m_aAxesScale[1], m_aAxesScale[2],
+                            m_aAxesTranslation[0], m_aAxesTranslation[1], m_aAxesTranslation[2] ) ;
   endDrawing();
 }
 /*-----------------------------------------------------------------------------------*/
index 7816a4a..15d23d4 100644 (file)
@@ -8,22 +8,27 @@
 #include "DrawableSubwin.h"
 #include "DrawableSubwinBridge.h"
 
+extern "C"
+{
+#include "GetProperty.h"
+}
+
 namespace sciGraphics
 {
 
 /*------------------------------------------------------------------------------------------*/
 DrawableSubwin::DrawableSubwin(sciPointObj * pObj) : DrawableClippedObject(pObj)
 {
- /* m_pCamera = NULL ;*/
+  m_pCamera = NULL ;
 }
 /*------------------------------------------------------------------------------------------*/
 DrawableSubwin::~DrawableSubwin( void )
 {
-  //if ( m_pCamera != NULL )
-  //{
-  //  delete m_pCamera ;
-  //}
-  //m_pCamera = NULL;
+  if ( m_pCamera != NULL )
+  {
+    delete m_pCamera ;
+  }
+  m_pCamera = NULL;
 }
 /*------------------------------------------------------------------------------------------*/
 void DrawableSubwin::draw( void )
@@ -34,11 +39,14 @@ void DrawableSubwin::draw( void )
   //  endDrawing();
   //  return;
   //}
-  //m_pCamera->setViewingArea(sciGetAxesBounds(m_pDrawed), sciGetMargins(m_pDrawed)) ;
-  //m_pCamera->renderPosition();
+  m_pCamera->setViewingArea(sciGetAxesBounds(m_pDrawed), sciGetMargins(m_pDrawed)) ;
+
+  double bounds[6] ;
+  sciGetRealDataBounds(m_pDrawed, bounds) ;
+  m_pCamera->setSubwinBox(bounds) ;
+  m_pCamera->renderPosition();
   displayChildren() ;
-  endDrawing();
-  //drawSubWinEntity( m_pDrawed ) ;
+  //endDrawing();
 }
 /*------------------------------------------------------------------------------------------*/
 void DrawableSubwin::show( void )
index 7cbf47b..944725c 100644 (file)
@@ -10,7 +10,7 @@
 
 
 #include "../DrawableClippedObject.h"
-//#include "Camera.h"
+#include "Camera.h"
 #include "DrawableSubwinBridge.h"
 
 namespace sciGraphics
@@ -28,9 +28,9 @@ public:
   /**
    * Set/Get the current camera
    */
-  /*Camera * getCamera( void ) { return m_pCamera; }
+  Camera * getCamera( void ) { return m_pCamera; }
 
-  void setCamera( Camera * cam ) { m_pCamera = cam ; }*/
+  void setCamera( Camera * cam ) { m_pCamera = cam ; }
 
 protected:
 
@@ -53,7 +53,7 @@ protected:
 
   /*--------------------------------------------------------------------------------------*/
   /** Camera used to visualize this axes */
-  /*Camera * m_pCamera;*/
+  Camera * m_pCamera;
   /*--------------------------------------------------------------------------------------*/
 
 
index bdba57f..2e9ed6f 100644 (file)
@@ -8,7 +8,7 @@
 
 #include "DrawableSubwinFactory.h"
 #include "DrawableSubwin.h"
-//#include "CameraFactory.h"
+#include "CameraFactory.h"
 #include "DrawableSubwinBridgeFactory.h"
 
 
@@ -25,9 +25,9 @@ DrawableObject * DrawableSubwinFactory::create( void )
   newSubwin->setDrawableImp(imp.create());
 
   // create the camera
-  //CameraFactory cf;
-  //cf.setCorrespondingSubwin(res) ;
-  //res->setCamera( cf.create() ) ;
+  CameraFactory cf;
+  cf.setCorrespondingSubwin(newSubwin) ;
+  newSubwin->setCamera( cf.create() ) ;
 
   return newSubwin;
 }
index 1de73d5..24702df 100644 (file)
@@ -73,9 +73,7 @@ public class DrawableFigureJoGL extends ObjectJoGL {
                // destroy all the objects
                destroyedObjects.destroyAll(parentFigureIndex);
                super.initializeDrawing(parentFigureIndex);
-               GL gl = getGL();
-           gl.glLoadIdentity();
-           gl.glTranslatef(0.0f, 0.0f, -6.0f);
+               getGL().glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
        }
        
        /**
@@ -187,9 +185,6 @@ public class DrawableFigureJoGL extends ObjectJoGL {
         * @param colorIndex index of the colro to use
         */
        public void setBackgroundColor(int colorIndex) {
-               if (getGL() == null) {
-                       updateGLContext(figureId);
-               }
                double[] color = getColorMap().getColor(colorIndex);
                getGL().glClearColor((float) color[0], (float) color[1], (float) color[2], 1.0f); // alpha is set to 1
                getGL().glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
index 8ead71e..fc40707 100644 (file)
@@ -68,7 +68,7 @@ public class SciRenderer
       }
       final GL gl = gLDrawable.getGL();
       gl.glShadeModel(GL.GL_SMOOTH);              // Enable Smooth Shading
-      gl.glClearColor(1.0f, 1.0f, 1.0f, 0.5f);    // white Background
+      gl.glClearColor(1.0f, 1.0f, 1.0f, 0.0f);    // white Background
       gl.glClearDepth(1.0f);                      // Depth Buffer Setup
       gl.glEnable(GL.GL_DEPTH_TEST);                                                   // Enables Depth Testing
       gl.glDepthFunc(GL.GL_LEQUAL);                                                            // The Type Of Depth Testing To Do
@@ -94,21 +94,20 @@ public class SciRenderer
    */
   public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height)
     {
-      final GL gl = gLDrawable.getGL();
-      //final GLU glu = new GLU();
-      float h = 1.0f; 
+         // not needed for now
+      //final GL gl = gLDrawable.getGL();
+      //float h = 1.0f;
 
-      if (height > 0) {
+      //if (height > 0) {
         // avoid a divide by zero error!
-        h = (float) height;
-      }
-      h = (float) width / h;
-      gl.glMatrixMode(GL.GL_PROJECTION);
-      gl.glLoadIdentity();
-      //glu.gluPerspective(45.0f, h, 1.0, 20.0);
-      gl.glFrustum(0.0, 1.0, 0.0, 1.0, 1.0, 20.0);
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glLoadIdentity();
+        //h = (float) height;
+      //}
+      //h = (float) width / h;
+      //gl.glMatrixMode(GL.GL_PROJECTION);
+      //gl.glLoadIdentity();
+      //gl.glFrustum(0.0, 1.0, 0.0, 1.0, 1.0, 20.0);
+      //gl.glMatrixMode(GL.GL_MODELVIEW);
+      //gl.glLoadIdentity();
 
     }
 
index 33de7de..d412c85 100644 (file)
@@ -9,14 +9,18 @@
 
 package org.scilab.modules.renderer.subwinDrawing;
 
-import org.scilab.modules.renderer.DrawableObjectJoGL;
+import org.scilab.modules.renderer.ObjectJoGL;
+import javax.media.opengl.GL;
 
 /**
  * Class containing the driver dependant routines position the camera.
  * @author Jean-Baptiste Silvy
  */
-public class CameraJoGL extends DrawableObjectJoGL {
+public class CameraJoGL extends ObjectJoGL {
 
+       /** Distance of the far clipping plane, should be greater than 1.0 and not to high */
+       private static final double FAR_PLANE_DISTANCE = 100.0;
+       
        /**
         * Default constructor
         */
@@ -36,9 +40,43 @@ public class CameraJoGL extends DrawableObjectJoGL {
        
        /**
         * Position the viewing area in order to respect Subwin position.
+        * @param transX X translation of the viewing area
+        * @param transY Y translation of the viewing area
+        * @param scaleX X scale of the viewing area
+        * @param scaleY Y scale of the viewing area
+        */
+       public void moveViewingArea(double transX, double transY, double scaleX, double scaleY) {
+               GL gl = getGL();
+               gl.glMatrixMode(GL.GL_PROJECTION);
+           gl.glLoadIdentity();
+           // with this the drawing view current scale for the view is [0,1]x[0,1]
+           // for perspective view, we need to use glFrustum, not gluPerpective
+           gl.glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, FAR_PLANE_DISTANCE);
+           gl.glMatrixMode(GL.GL_MODELVIEW);
+           gl.glLoadIdentity();
+
+               gl.glTranslated(transX, transY, 0.0);
+               gl.glScaled(scaleX, scaleY, 1.0);
+               //gl.glTranslatef(0.0f, 0.0f, -1.0f); 
+               
+       }
+       
+       /**
+        * Move the axes box so it fit the viewing area
+        * @param scaleX X scale to fit user axes coordinates
+        * @param scaleY Y scale to fit user axes coordinates
+        * @param scaleZ Z scale to fit user axes coordinates
+        * @param transX X translation to put the axes in view
+        * @param transY Y translation to put the axes in view
+        * @param transZ Z translation to put the axes in view
         */
-       public void moveViewingArea() {
-               System.err.println("Moving  viewing area");
+       public void moveAxesBox(double scaleX, double scaleY, double scaleZ,
+                                                       double transX, double transY, double transZ) {
+               GL gl = getGL();
+               System.out.println("scaleX = " + scaleX + "scaleY = " + scaleY + "scaleZ = " + scaleZ);
+               gl.glScaled(scaleX, scaleY, scaleZ);
+               System.out.println("transX = " + transX + "transY = " + transY + "transZ = " + transZ);
+               gl.glTranslated(transX, transY, transZ);
        }