Bug 12399 fixed: Bad data bounds computation with %inf and log scale 88/10888/4
Calixte DENIZET [Tue, 19 Mar 2013 14:53:54 +0000 (15:53 +0100)]
Change-Id: I8fda6053df7a52c7e5759a0a075be40a46d3ee14

scilab/CHANGES_5.4.X
scilab/modules/graphic_objects/src/java/org/scilab/modules/graphic_objects/axes/Axes.java
scilab/modules/graphics/includes/math_graphics.h
scilab/modules/graphics/src/c/BasicAlgos.c
scilab/modules/graphics/src/c/Plo2dn.c
scilab/modules/graphics/src/c/math_graphics.c
scilab/modules/graphics/tests/nonreg_tests/bug_12399.dia.ref [new file with mode: 0644]
scilab/modules/graphics/tests/nonreg_tests/bug_12399.tst [new file with mode: 0644]

index 753ed5f..50b4fe6 100644 (file)
@@ -603,11 +603,13 @@ Bug fixes
 
 * Bug #12396 fixed - Example "Problem 2" was missing a variable in bvode help page.
 
+* Bug #12399 fixed - Bad data bounds computation with %inf and log scale.
+
 * Bug #12405 fixed - Floating point errors could lead to an infinite loop in
                      ticks computation.
 
 * Bug #12406 fixed - In SciNotes, whereami numbering failed when a variable name
-                     started with endfunction. 
+                     started with endfunction.
 
 * Bug #12418 fixed - Continuation was incorrectly supported in bvode.
 
index 4f1827e..63abc0d 100644 (file)
@@ -1910,20 +1910,16 @@ public class Axes extends GraphicObject {
     public Double[] getMaximalDisplayedBounds() {
         Double[] bounds = getDataBounds();
 
-        /**
-         * Remove 0 sized bounds
-         */
-        for (int i = 0 ; i < 6 ; i += 2) {
-            if (bounds[i].equals(bounds[i + 1])) {
-                bounds[i]--;
-                bounds[i + 1]++;
-            }
-        }
-
+        boolean eq = bounds[0].equals(bounds[1]);
         if (getXAxisLogFlag()) {
             bounds[0] = Math.log10(bounds[0]);
             bounds[1] = Math.log10(bounds[1]);
         }
+        if (eq) {
+            // Avoid to have same bounds.
+            bounds[0]--;
+            bounds[1]++;
+        }
 
         if (getXAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
             if (0 < bounds[0]) {
@@ -1933,10 +1929,15 @@ public class Axes extends GraphicObject {
             }
         }
 
+        eq = bounds[2].equals(bounds[3]);
         if (getYAxisLogFlag()) {
             bounds[2] = Math.log10(bounds[2]);
             bounds[3] = Math.log10(bounds[3]);
         }
+        if (eq) {
+            bounds[2]--;
+            bounds[3]++;
+        }
 
         if (getYAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
             if (0 < bounds[2]) {
@@ -1946,10 +1947,15 @@ public class Axes extends GraphicObject {
             }
         }
 
+        eq = bounds[4].equals(bounds[5]);
         if (getZAxisLogFlag()) {
             bounds[4] = Math.log10(bounds[4]);
             bounds[5] = Math.log10(bounds[5]);
         }
+        if (eq) {
+            bounds[4]--;
+            bounds[5]++;
+        }
 
         if (getZAxisLocationAsEnum() == AxisProperty.AxisLocation.ORIGIN) {
             if (0 < bounds[4]) {
index 83f23ec..b2d38f8 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 1998 - 2000 - ENPC - Jean-Philipe Chancelier
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 #include "BOOL.h"
 #include "core_math.h"
 
-#ifdef _MSC_VER 
-               #include <float.h>
-               #define finite(x) _finite(x) 
-#else  /* _MSC_VER */ 
-       /** This should only be provided when finite prototype is missing **/
-       /** XXX : to be tested **/
-       #ifndef __cplusplus
-       int finite (double);
-       #endif
+#ifdef _MSC_VER
+#include <float.h>
+#define finite(x) _finite(x)
+#else  /* _MSC_VER */
+/** This should only be provided when finite prototype is missing **/
+/** XXX : to be tested **/
+#ifndef __cplusplus
+int finite (double);
+#endif
 #endif /* _MSC_VER */
 
-#ifdef _MSC_VER 
-       #include <float.h>
-       #define ISNAN(x) _isnan(x)
-#else 
-       #define ISNAN(x) isnan(x)
-#endif 
+#ifdef _MSC_VER
+#include <float.h>
+#define ISNAN(x) _isnan(x)
+#else
+#define ISNAN(x) isnan(x)
+#endif
 
 
 #define PI0 (int *) 0
 #define                round(a)        (int)(((a)<0.0)?(a)-.5:(a)+.5)
 #define EPSILON 1.0e-13
 
-#define linint(x) ((int)  floor(x + 0.5 )) 
-#define inint(x) ((int) floor(x + 0.5 ))  
+#define linint(x) ((int)  floor(x + 0.5 ))
+#define inint(x) ((int) floor(x + 0.5 ))
 
-#if (defined(sun) || defined(SYSV)) 
+#if (defined(sun) || defined(SYSV))
 #include <ieeefp.h>
 #endif
 
 #if defined(_MSC_VER)
-  #define M_PI 3.14159265358979323846
+#define M_PI 3.14159265358979323846
 #else
-  #if defined(HAVE_VALUES_H)
-    #include <values.h>
-  #else
-    #if defined(HAVE_LIMITS_H)
-     #include <limits.h>
-    #endif
-  #endif
+#if defined(HAVE_VALUES_H)
+#include <values.h>
+#else
+#if defined(HAVE_LIMITS_H)
+#include <limits.h>
+#endif
+#endif
 #endif
 
 #ifndef M_PI
-#define M_PI 3.14159265358979323846 
+#define M_PI 3.14159265358979323846
 #endif
 
 GRAPHICS_IMPEXP double Mini(const double vect[], int n) ;
 
 GRAPHICS_IMPEXP double Maxi(const double vect[], int n) ;
 
-
+GRAPHICS_IMPEXP void MiniMaxi(const double vect[], int n, double * const min, double * const max);
 
 /* prototypes */
 
@@ -96,10 +96,10 @@ GRAPHICS_IMPEXP void rotate2D( double from[2], double center[2], double angle, d
 /* perform the rotation of point from to point to. */
 /* the angle is directly given with its sine and cosine for speed */
 GRAPHICS_IMPEXP void rotate2Dim( double from[2]   ,
-                 double center[2] ,
-                 double cosAngle  ,
-                 double sinAngle  ,
-                 double dest[2]    ) ;
+                                 double center[2] ,
+                                 double cosAngle  ,
+                                 double sinAngle  ,
+                                 double dest[2]    ) ;
 
 /* perform the translation of point from to point dest with vector trans */
 GRAPHICS_IMPEXP void translate2D( double from[2], double trans[2], double dest[2] ) ;
@@ -153,13 +153,13 @@ GRAPHICS_IMPEXP void scalarMult2D(const double v[2], const double scalar, double
  * Compute wether the point lies within the triangle defined by A, B and C
  */
 GRAPHICS_IMPEXP BOOL isPointInTriangle(const double point[2], const double a[2],
-                       const double b[2], const double c[2]);
+                                       const double b[2], const double c[2]);
 
 /**
  * Compute wether p1 and p2 are on the same side of line (A,B).
  */
 GRAPHICS_IMPEXP BOOL areOnSameSideOfLine(const double p1[2], const double p2[2],
-                         const double a[2], const double b[2]);
+        const double a[2], const double b[2]);
 
 /************************************************************************/
 /* 3D algorithms                                                        */
index 8a90af0..63cd9f3 100644 (file)
 /*------------------------------------------------------------------------*/
 double sciFindStPosMin( const double x[], int n )
 {
-  double min = 0.;
-  int i = 0;
+    double min = 0.;
+    int i = 0;
 
-  if ( n <= 0 )
-  {
-    return -1.0 ;
-  }
+    if ( n <= 0 )
+    {
+        return -1.0;
+    }
 
-  min = x[0] ;
+    min = x[0];
 
-  for ( i = 1 ; i < n ; i++ )
-  {
-    if ( x[i] > 0.0 && x[i] < min )
+    for (i = 1 ; i < n ; i++)
     {
-      min = x[i] ;
+        if (x[i] > 0.0 && x[i] < min)
+        {
+            min = x[i] ;
+        }
     }
-  }
 
-  /* if we have found at least one positive value in x, min strictly positive */
-  return min ;
+    /* if we have found at least one positive value in x, min strictly positive */
+    return min ;
 }
 /*------------------------------------------------------------------------*/
 int checkMonotony( const double vector[], int nbElement )
 {
-  int i = 0;
-  if( vector[1] >= vector[0] )
-  {
-    /* might be increasing */
-    for ( i = 1 ; i < nbElement - 1 ; i++ )
+    int i = 0;
+    if ( vector[1] >= vector[0] )
     {
-      if ( vector[i+1] < vector[i] )
-      {
-        /* not increasing */
-        return 0 ;
-      }
+        /* might be increasing */
+        for ( i = 1 ; i < nbElement - 1 ; i++ )
+        {
+            if ( vector[i + 1] < vector[i] )
+            {
+                /* not increasing */
+                return 0 ;
+            }
+        }
+        return 1 ;
     }
-    return 1 ;
-  }
-  else
-  {
-    /* might be decreasing */
-    for ( i = 1 ; i < nbElement - 1 ; i++ )
+    else
     {
-      if ( vector[i+1] > vector[i] )
-      {
-        /* not decreasing */
-        return 0 ;
-      }
-    }
-    return -1 ;
+        /* might be decreasing */
+        for ( i = 1 ; i < nbElement - 1 ; i++ )
+        {
+            if ( vector[i + 1] > vector[i] )
+            {
+                /* not decreasing */
+                return 0 ;
+            }
+        }
+        return -1 ;
 
-  }
-  return 0 ;
+    }
+    return 0 ;
 
 }
 /*------------------------------------------------------------------------*/
 BOOL containsOneFiniteElement(const double vector[], int nbElement)
 {
-       int i = 0;
-       for (i = 0; i < nbElement; i++)
-       {
-               if (finite(vector[i]))
-               {
-                       return TRUE;
-               }
-       }
-       return FALSE;
+    int i = 0;
+    for (i = 0; i < nbElement; i++)
+    {
+        if (finite(vector[i]))
+        {
+            return TRUE;
+        }
+    }
+    return FALSE;
 }
 /*------------------------------------------------------------------------*/
 void doubleArrayCopy( double dest[], const double src[], int nbElement )
 {
-  memcpy( dest, src, nbElement * sizeof(double) ) ;
+    memcpy( dest, src, nbElement * sizeof(double) ) ;
 }
 /*------------------------------------------------------------------------*/
 void intArrayCopy( int dest[], const int src[], int nbElement )
 {
-  memcpy( dest, src, nbElement * sizeof(int) ) ;
+    memcpy( dest, src, nbElement * sizeof(int) ) ;
 }
 /*------------------------------------------------------------------------*/
 void stringArrayCopy( char * dest[], char * src[], int nbElement )
 {
-  int i = 0;
-  for ( i = 0 ; i < nbElement ; i++ )
-  {
-    int elemSize =  (int)strlen( src[i] ) + 1 ;
-    FREE( dest[i] ) ;
+    int i = 0;
+    for ( i = 0 ; i < nbElement ; i++ )
+    {
+        int elemSize =  (int)strlen( src[i] ) + 1 ;
+        FREE( dest[i] ) ;
 
-    dest[i] = MALLOC( elemSize * sizeof(char) ) ;
+        dest[i] = MALLOC( elemSize * sizeof(char) ) ;
 
-    if ( dest[i] == NULL )
-    {
-      destroyStringArray( dest, nbElement ) ;
-      return ;
-    }
+        if ( dest[i] == NULL )
+        {
+            destroyStringArray( dest, nbElement ) ;
+            return ;
+        }
 
-    strcpy( dest[i], src[i] ) ;
-  }
+        strcpy( dest[i], src[i] ) ;
+    }
 }
 /*------------------------------------------------------------------------*/
 void setDoubleArraySingleValue( double dest[], double value, int nbElement )
 {
-  int i = 0;
-  for ( i = 0 ; i < nbElement ; i++ )
-  {
-    dest[i] = value ;
-  }
+    int i = 0;
+    for ( i = 0 ; i < nbElement ; i++ )
+    {
+        dest[i] = value ;
+    }
 }
 /*------------------------------------------------------------------------*/
 double * createNewArrayFromSource( int destSize, const double src[], int srcSize )
 {
-  int i = 0;
-  int endCopy = Min( destSize, srcSize ) ;
-  /* create new array */
-  double * dest = MALLOC( destSize * sizeof(double) ) ;
+    int i = 0;
+    int endCopy = Min( destSize, srcSize ) ;
+    /* create new array */
+    double * dest = MALLOC( destSize * sizeof(double) ) ;
 
-  if ( dest == NULL )
-  {
-    return NULL ;
-  }
+    if ( dest == NULL )
+    {
+        return NULL ;
+    }
 
-  /* copy the element which needs to be copied */
-  memcpy( dest, src, endCopy * sizeof( double ) ) ;
+    /* copy the element which needs to be copied */
+    memcpy( dest, src, endCopy * sizeof( double ) ) ;
 
-  for ( i = endCopy ; i < destSize ; i++ )
-  {
-    dest[i] = 0.0 ;
-  }
+    for ( i = endCopy ; i < destSize ; i++ )
+    {
+        dest[i] = 0.0 ;
+    }
 
-  return dest ;
+    return dest ;
 
 }
 /*------------------------------------------------------------------------*/
 void destroyStringArray( char * src[], int nbStrings )
 {
-       freeArrayOfString(src, nbStrings);
+    freeArrayOfString(src, nbStrings);
 }
 /*--------------------------------------------------------------------------*/
 double * createDoubleArrayCopy( const double src[], int nbElement )
 {
-  double * res = MALLOC( nbElement * sizeof(double) ) ;
+    double * res = MALLOC( nbElement * sizeof(double) ) ;
 
-  if ( res == NULL )
-  {
-    return NULL ;
-  }
+    if ( res == NULL )
+    {
+        return NULL ;
+    }
 
-  memcpy( res, src, nbElement * sizeof(double) ) ;
+    memcpy( res, src, nbElement * sizeof(double) ) ;
 
-  return res ;
+    return res ;
 }
 /*--------------------------------------------------------------------------*/
 int * createIntArrayCopy( const int src[], int nbElement )
 {
-  int * res = MALLOC( nbElement * sizeof(int) ) ;
+    int * res = MALLOC( nbElement * sizeof(int) ) ;
 
-  if ( res == NULL )
-  {
-    return NULL ;
-  }
+    if ( res == NULL )
+    {
+        return NULL ;
+    }
 
-  memcpy( res, src, nbElement * sizeof(int) ) ;
+    memcpy( res, src, nbElement * sizeof(int) ) ;
 
-  return res ;
+    return res ;
 }
 /*--------------------------------------------------------------------------*/
 char ** createStringArrayCopy( char * src[], int nbElement )
 {
-  char ** res = createStringArray(nbElement);
+    char ** res = createStringArray(nbElement);
 
-  if ( res == NULL )
-  {
-    return NULL ;
-  }
+    if ( res == NULL )
+    {
+        return NULL ;
+    }
 
-  stringArrayCopy( res, src, nbElement ) ;
+    stringArrayCopy( res, src, nbElement ) ;
 
-  return res ;
+    return res ;
 
 }
 /*--------------------------------------------------------------------------*/
 char ** createStringArray(int nbElement)
 {
-  int i = 0;
-  char ** res = MALLOC( nbElement * sizeof(char *) ) ;
+    int i = 0;
+    char ** res = MALLOC( nbElement * sizeof(char *) ) ;
 
-  if ( res == NULL )
-  {
-    return NULL ;
-  }
+    if ( res == NULL )
+    {
+        return NULL ;
+    }
 
-  for ( i = 0 ; i < nbElement; i++ )
-  {
-    res[i] = NULL ;
-  }
+    for ( i = 0 ; i < nbElement; i++ )
+    {
+        res[i] = NULL ;
+    }
 
-  return res ;
+    return res ;
 }
 /*--------------------------------------------------------------------------*/
index 77a322d..843eb7b 100644 (file)
@@ -179,9 +179,13 @@ int plot2dn(int ptype, char *logflags, double *x, double *y, int *n1, int *n2, i
             case '9':
                 /* Force data bounds to the x and y bounds */
                 if ((int)strlen(logflags) < 1)
+                {
                     dataflag = 'g';
+                }
                 else
+                {
                     dataflag = logflags[0];
+                }
 
                 getGraphicObjectProperty(psubwinUID, __GO_X_AXIS_LOG_FLAG__, jni_bool, (void **)&piTmp);
                 logFlags[0] = iTmp;
@@ -473,7 +477,7 @@ int plot2dn(int ptype, char *logflags, double *x, double *y, int *n1, int *n2, i
             setGraphicObjectRelationship(psubwinUID, compoundUID);
             getGraphicObjectProperty(psubwinUID, __GO_VISIBLE__, jni_bool, (void **)&piParentVisible);
             setGraphicObjectProperty(compoundUID, __GO_VISIBLE__, &parentVisible, jni_bool, 1);
-           releaseGraphicObjectProperty(__GO_PARENT__, compoundUID, jni_string, 1);
+            releaseGraphicObjectProperty(__GO_PARENT__, compoundUID, jni_string, 1);
         }
         FREE(hdltab);
 
@@ -516,8 +520,9 @@ void compute_data_bounds2(int cflag, char dataflag, char *logflags, double *x, d
     {
         if (logflags[0] != 'l')
         {
-            drect[0] = Mini(x1, size_x);
-            drect[1] = Maxi(x1, size_x);
+            MiniMaxi(x1, size_x, drect, drect + 1);
+            //drect[0] = Mini(x1, size_x);
+            //drect[1] = Maxi(x1, size_x);
         }
         else
         {
@@ -547,8 +552,9 @@ void compute_data_bounds2(int cflag, char dataflag, char *logflags, double *x, d
     {
         if (logflags[1] != 'l')
         {
-            drect[2] = Mini(y, size_y);
-            drect[3] = Maxi(y, size_y);
+            MiniMaxi(y, size_y, drect + 2, drect + 3);
+            //drect[2] = Mini(y, size_y);
+            //drect[3] = Maxi(y, size_y);
         }
         else
         {
@@ -556,7 +562,6 @@ void compute_data_bounds2(int cflag, char dataflag, char *logflags, double *x, d
             drect[2] = sciFindStPosMin(y, size_y);
             drect[3] = Maxi(y, size_y);
         }
-
     }
     else
     {
@@ -572,18 +577,35 @@ void compute_data_bounds2(int cflag, char dataflag, char *logflags, double *x, d
             drect[3] = 10.0;
         }
     }
+
     /* back to default values for  x=[] and y = [] */
-    if (drect[2] == LARGEST_REAL)
+    if (drect[2] == LARGEST_REAL || drect[3] == -LARGEST_REAL)
     {
-        drect[2] = 0.0;
+        if (logflags[1] != 'l')
+        {
+            drect[2] = 0.0;
+        }
+        else
+        {
+            drect[2] = 1.0;
+        }
+
         drect[3] = 10.0;
     }
-    if (drect[0] == LARGEST_REAL)
+
+    if (drect[0] == LARGEST_REAL || drect[1] == -LARGEST_REAL)
     {
-        drect[0] = 0.0;
+        if (logflags[0] != 'l')
+        {
+            drect[0] = 0.0;
+        }
+        else
+        {
+            drect[0] = 1.0;
+        }
+
         drect[1] = 10.0;
     }
-
 }
 
 BOOL update_specification_bounds(char *psubwinUID, double rect[6], int flag)
index 3bacd4a..fd93efd 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 1998-2001 - ENPC - Jean-Philippe Chancelier
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 
 #include "math_graphics.h"
 
-/* 
- * we use spConfig.h for machine constants 
- * XXX : spConfig should be merged and unified 
- *       with other machine constant scilab code 
+/*
+ * we use spConfig.h for machine constants
+ * XXX : spConfig should be merged and unified
+ *       with other machine constant scilab code
  */
 
 #define spINSIDE_SPARSE
 
 double Mini(const double vect[], int n)
 {
-  int i = 0;
-  double vmin = LARGEST_REAL;
-  for (i = 0 ; i < n ; i++)
-    /*    if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] < vmin)  */
-    if ( finite(vect[i])== 1 && vect[i] < vmin) 
-      vmin=vect[i];
-  return(vmin);
+    int i = 0;
+    double vmin = LARGEST_REAL;
+    for (; i < n ; i++)
+    {
+        /*    if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] < vmin)  */
+        if (finite(vect[i]) == 1 && vect[i] < vmin)
+        {
+            vmin = vect[i];
+        }
+    }
+
+    return vmin;
 }
 
 double Maxi(const double vect[], int n)
 {
-  int i = 0;
-  double maxi = - LARGEST_REAL;
-  for (i =0 ; i < n ; i++)
-    /* if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] > maxi) */
-    if ( finite(vect[i])== 1 && vect[i] > maxi) 
-      maxi=vect[i];
-  return(maxi);
+    int i = 0;
+    double maxi = -LARGEST_REAL;
+    for (; i < n ; i++)
+    {
+        /* if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] > maxi) */
+        if (finite(vect[i]) == 1 && vect[i] > maxi)
+        {
+            maxi = vect[i];
+        }
+    }
+
+    return maxi;
+}
+
+void MiniMaxi(const double vect[], int n, double * const min, double * const max)
+{
+    int i = 0;
+    double _min = LARGEST_REAL;
+    double _max = -LARGEST_REAL;
+    for (; i < n ; i++)
+    {
+        /*    if ( isinf(vect[i])== 0 && isnan(vect[i])==0 && vect[i] < vmin)  */
+        if (finite(vect[i]) == 1)
+        {
+            if (vect[i] < _min)
+            {
+                _min = vect[i];
+            }
+            if (vect[i] > _max)
+            {
+                _max = vect[i];
+            }
+        }
+    }
+
+    *min = _min;
+    *max = _max;
 }
 
 /*----------------------------------------------------------------------------*/
@@ -53,7 +88,7 @@ double Maxi(const double vect[], int n)
 /* perform the rotation of point from to point dest  */
 void rotate2D( double from[2], double center[2], double angle, double dest[2] )
 {
-  rotate2Dim( from, center, cos( angle ), sin( angle ), dest ) ;
+    rotate2Dim( from, center, cos( angle ), sin( angle ), dest ) ;
 }
 
 /*----------------------------------------------------------------------------*/
@@ -65,165 +100,166 @@ void rotate2Dim( double from[2]   ,
                  double sinAngle  ,
                  double dest[2]    )
 {
-  double diff[2] ;
+    double diff[2] ;
 
-  /* put the center to (0,0) */
-  diff[0] = from[0] - center[0] ;
-  diff[1] = from[1] - center[1] ;
+    /* put the center to (0,0) */
+    diff[0] = from[0] - center[0] ;
+    diff[1] = from[1] - center[1] ;
 
-  /* turn and translate back */
-  dest[0] = diff[0] * cosAngle - diff[1] * sinAngle + center[0] ;
-  dest[1] = diff[0] * sinAngle + diff[1] * cosAngle + center[1] ;
+    /* turn and translate back */
+    dest[0] = diff[0] * cosAngle - diff[1] * sinAngle + center[0] ;
+    dest[1] = diff[0] * sinAngle + diff[1] * cosAngle + center[1] ;
 }
 /*----------------------------------------------------------------------------*/
 /* perform the translation of point from to point to with vector trans */
 void translate2D( double from[2], double trans[2], double dest[2] )
 {
-  dest[0] = from[0] + trans[0] ;
-  dest[1] = from[1] + trans[1] ;
+    dest[0] = from[0] + trans[0] ;
+    dest[1] = from[1] + trans[1] ;
 }
 /*----------------------------------------------------------------------------*/
 void iTranslate2D( int from[2], int trans[2], int dest[2] )
 {
-  dest[0] = from[0] + trans[0] ;
-  dest[1] = from[1] + trans[1] ;
+    dest[0] = from[0] + trans[0] ;
+    dest[1] = from[1] + trans[1] ;
 }
 /*----------------------------------------------------------------------------*/
 void vectSubstract2D(const double vect1[2], const double vect2[], double res[2])
 {
-  res[0] = vect1[0] - vect2[0];
-  res[1] = vect1[1] - vect2[1];
+    res[0] = vect1[0] - vect2[0];
+    res[1] = vect1[1] - vect2[1];
 }
 /*----------------------------------------------------------------------------*/
 void vectAdd2D(const double v1[2], const double v2[2], double res[2])
 {
-  res[0] = v1[0] + v2[0];
-  res[1] = v1[1] + v2[1];
+    res[0] = v1[0] + v2[0];
+    res[1] = v1[1] + v2[1];
 }
 /*----------------------------------------------------------------------------*/
 void scalarMult2D(const double v[2], const double scalar, double res[2])
 {
-  res[0] = scalar * v[0];
-  res[1] = scalar * v[1];
+    res[0] = scalar * v[0];
+    res[1] = scalar * v[1];
 }
 /*----------------------------------------------------------------------------*/
 void normalize2d( double vect[2] )
 {
-  double norm = NORM_2D(vect) ;
-  vect[0] /= norm ;
-  vect[1] /= norm ;
+    double norm = NORM_2D(vect) ;
+    vect[0] /= norm ;
+    vect[1] /= norm ;
 }
 /*----------------------------------------------------------------------------*/
 void iNormalize2d( int vect[2] )
 {
-  double norm = NORM_2D(vect) ;
-  vect[0] = round( vect[0] / norm ) ;
-  vect[1] = round( vect[1] / norm ) ;
+    double norm = NORM_2D(vect) ;
+    vect[0] = round( vect[0] / norm ) ;
+    vect[1] = round( vect[1] / norm ) ;
 }
 /*----------------------------------------------------------------------------*/
 BOOL isPointInTriangle(const double point[2], const double a[2],
                        const double b[2], const double c[2])
 {
-  return (   areOnSameSideOfLine(point, a, b, c)
-          && areOnSameSideOfLine(point, b, a, c)
-          && areOnSameSideOfLine(point, c, a, b));
+    return (   areOnSameSideOfLine(point, a, b, c)
+               && areOnSameSideOfLine(point, b, a, c)
+               && areOnSameSideOfLine(point, c, a, b));
 }
 /*----------------------------------------------------------------------------*/
 BOOL areOnSameSideOfLine(const double p1[2], const double p2[2],
                          const double a[2], const double b[2])
 {
-  // point are on the same if and only if (AB^AP1).(AB^AP2) >= 0
-  double ab[3];
-  double ap1[3];
-  double ap2[3];
-  double cp1[3];
-  double cp2[3];
+    // point are on the same if and only if (AB^AP1).(AB^AP2) >= 0
+    double ab[3];
+    double ap1[3];
+    double ap2[3];
+    double cp1[3];
+    double cp2[3];
+
+    ab[0] = b[0] - a[0];
+    ab[1] = b[1] - a[1];
+    ab[2] = 0.0;
 
-  ab[0] = b[0] - a[0];
-  ab[1] = b[1] - a[1];
-  ab[2] = 0.0;
-  ap1[0] = p1[0] - a[0];
-  ap1[1] = p1[1] - a[1];
-  ap1[2] = 0.0;
+    ap1[0] = p1[0] - a[0];
+    ap1[1] = p1[1] - a[1];
+    ap1[2] = 0.0;
 
-  ap2[0] = p2[0] - a[0];
-  ap2[1] = p2[1] - a[1];
-  ap2[2] = 0.0;
+    ap2[0] = p2[0] - a[0];
+    ap2[1] = p2[1] - a[1];
+    ap2[2] = 0.0;
 
-  crossProduct(ab, ap1, cp1);
-  crossProduct(ab, ap2, cp2);
+    crossProduct(ab, ap1, cp1);
+    crossProduct(ab, ap2, cp2);
 
-  return (DOT_PROD_3D(cp1, cp2) >= 0.0);
+    return (DOT_PROD_3D(cp1, cp2) >= 0.0);
 
 }
 /*----------------------------------------------------------------------------*/
 void crossProduct( const double v1[3], const double v2[3], double res[3] )
 {
-  /* save data to be able to use v1 o v2 as res */
-  double v10 = v1[0];
-  double v20 = v2[0];
-  double v11 = v1[1];
-  double v21 = v2[1];
-  res[0] = v11 * v2[2] - v1[2] * v21 ;
-  res[1] = v1[2] * v20 - v10 * v2[2] ;
-  res[2] = v10 * v21 - v11 * v20 ;
+    /* save data to be able to use v1 o v2 as res */
+    double v10 = v1[0];
+    double v20 = v2[0];
+    double v11 = v1[1];
+    double v21 = v2[1];
+    res[0] = v11 * v2[2] - v1[2] * v21 ;
+    res[1] = v1[2] * v20 - v10 * v2[2] ;
+    res[2] = v10 * v21 - v11 * v20 ;
 }
 /*----------------------------------------------------------------------------*/
-void vectSubstract3D(const double v1[3] ,const double v2[3], double res[3])
+void vectSubstract3D(const double v1[3] , const double v2[3], double res[3])
 {
-  res[0] = v1[0] - v2[0];
-  res[1] = v1[1] - v2[1];
-  res[2] = v1[2] - v2[2];
+    res[0] = v1[0] - v2[0];
+    res[1] = v1[1] - v2[1];
+    res[2] = v1[2] - v2[2];
 }
 /*----------------------------------------------------------------------------*/
 void vectAdd3D(const double v1[3], const double v2[3], double res[3])
 {
-  res[0] = v1[0] + v2[0];
-  res[1] = v1[1] + v2[1];
-  res[2] = v1[2] + v2[2];
+    res[0] = v1[0] + v2[0];
+    res[1] = v1[1] + v2[1];
+    res[2] = v1[2] + v2[2];
 }
 /*----------------------------------------------------------------------------*/
 void scalarMult3D(const double v[3], double scalar, double res[3])
 {
-  res[0] = scalar * v[0];
-  res[1] = scalar * v[1];
-  res[2] = scalar * v[2];
+    res[0] = scalar * v[0];
+    res[1] = scalar * v[1];
+    res[2] = scalar * v[2];
 }
 /*----------------------------------------------------------------------------*/
 void normalize3D( double vect[3] )
 {
-  double norm = NORM_3D(vect) ;
-  vect[0] /= norm ;
-  vect[1] /= norm ;
-  vect[2] /= norm ;
+    double norm = NORM_3D(vect) ;
+    vect[0] /= norm ;
+    vect[1] /= norm ;
+    vect[2] /= norm ;
 }
 /*----------------------------------------------------------------------------*/
 void setToIdentity(double mat4D[4][4])
 {
-  int i = 0;
-  int j = 0;
-  for (i = 0; i < 4; i++)
-  {
-    for (j = 0; j < 4; j++)
+    int i = 0;
+    int j = 0;
+    for (i = 0; i < 4; i++)
     {
-      mat4D[i][j] = 0.0;
+        for (j = 0; j < 4; j++)
+        {
+            mat4D[i][j] = 0.0;
+        }
+        mat4D[i][i] = 1.0;
     }
-    mat4D[i][i] = 1.0;
-  }
 }
 /*----------------------------------------------------------------------------*/
 void mat4DMult(const double mat4D[4][4], const double vect3D[3], double res[3])
 {
-  int i = 0;
-  double res4D[4];
-  // w coordinate of the vector is supposed to be 1;
-  for (i = 0; i < 4; i++) {
-    res4D[i]  =  vect3D[0] * mat4D[i][0] + vect3D[1] * mat4D[i][1]
-               + vect3D[2] * mat4D[i][2] + mat4D[i][3];
-  }
-  res[0] = res4D[0] / res4D[3];
-  res[1] = res4D[1] / res4D[3];
-  res[2] = res4D[2] / res4D[3];
+    int i = 0;
+    double res4D[4];
+    // w coordinate of the vector is supposed to be 1;
+    for (i = 0; i < 4; i++)
+    {
+        res4D[i]  =  vect3D[0] * mat4D[i][0] + vect3D[1] * mat4D[i][1]
+                     + vect3D[2] * mat4D[i][2] + mat4D[i][3];
+    }
+    res[0] = res4D[0] / res4D[3];
+    res[1] = res4D[1] / res4D[3];
+    res[2] = res4D[2] / res4D[3];
 }
 /*----------------------------------------------------------------------------*/
diff --git a/scilab/modules/graphics/tests/nonreg_tests/bug_12399.dia.ref b/scilab/modules/graphics/tests/nonreg_tests/bug_12399.dia.ref
new file mode 100644 (file)
index 0000000..ee289a9
--- /dev/null
@@ -0,0 +1,20 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013-2013 - Scilab Enterprises - Bruno JOFRET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- TEST WITH GRAPHIC -->
+// <-- Non-regression test for bug 12399 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=12399
+//
+// <-- Short Description -->
+// Using plot2d with log scale and limits values may freeze Scilab
+plot2d(%inf);
+delete(gcf());
+plot2d("nl", %inf);
+delete(gcf());
+plot2d("nl", %nan);
+delete(gcf());
diff --git a/scilab/modules/graphics/tests/nonreg_tests/bug_12399.tst b/scilab/modules/graphics/tests/nonreg_tests/bug_12399.tst
new file mode 100644 (file)
index 0000000..f8a3bbf
--- /dev/null
@@ -0,0 +1,25 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013-2013 - Scilab Enterprises - Bruno JOFRET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- TEST WITH GRAPHIC -->
+
+// <-- Non-regression test for bug 12399 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=12399
+//
+// <-- Short Description -->
+// Using plot2d with log scale and limits values may freeze Scilab
+
+plot2d(%inf);
+delete(gcf());
+
+plot2d("nl", %inf);
+delete(gcf());
+
+plot2d("nl", %nan);
+delete(gcf());
\ No newline at end of file