Objects.h

Go to the documentation of this file.

/* © 1998 JRM Technologies, Inc.*/



/***********************************
Copyright JRM Enterprises, Inc. 1998
All rights reserved.

This code is the intellectual property of JRM Enterprises, Inc.
It may not be used or released as source or compiled binary form
without the prior written consent of JRM Enterprises, Inc.
***********************************/


#ifndef OBJECTS_H_
#define OBJECTS_H_

#include "sigsimDLLstub.h"
#include "CTDR-CPDR.h"
#include "Sonar.h"


#ifdef __cplusplus
extern "C"
{
#endif



    /* ------------ DEFINITIONS, ENUMERANTS, and DATA STRUCTURES ------------------ */


    //--------------Grabbed UPLIM #define and - Stuck in SigSimDefines-----------------//
    //--------------Grabbed HITTOL #define and - Stuck in objects.c file-----------------//

    typedef enum
    {
        TERRAIN,
        AIRCRAFT,
        GROUND_VEHICLE,
        WATERSURFACE,
        UNDERWATER,
        NONENTITY
    } OBJECT_TYPE;

    typedef struct
    {
        jrmbool active;       
        double thrust;        // [kg/hr] engine thrust
    } OBJECT_STATE;        // stub

    typedef struct
    {
        VECTOR Rview;   // unit vector tangent to refracted path (at sensor location)  to ID [unitless cosines, in sensor-local (North, East, Down) system]
        VECTOR Rtarget; // Orientation of path away from target in target local NED system. [unitless cosines]
        double Range;   // Path length [m]
        double Rdot; // rate of change of Refracted LOS path length [m/s].
    } Rpath;


    typedef struct 
    {
        char imagefile[SIGSIM_STRING_SIZE];
        double Rmax,Rmin;
    } OBJECT_SIDE_VIEW;

    typedef struct
    {
        char object_id[SIGSIM_STRING_SIZE];
        char object_subdirectory[SIGSIM_STRING_SIZE];
        OBJECT_TYPE object_type;       
        OBJECT_STATE state;

        int ntracks;                   // Number of TRACKS in track array
        TRACK *track;                     // Expected trajectory        
        GEODETIC_LOCATION geod_loc;          // Position of origin of local FRD system
        GEOCENTRIC_LOCATION geoc_loc;        // Position of origin of local FRD system
        EULERzyx FRD_orientation;            // Relates object body FRD to instantaneous local NED.
        VECTOR ned_linear_velocity;          // [m/s] Current linear velocity
        VECTOR ned_linear_acceleration;         // [m/s2] Curent linear acceleration
        VECTOR ned_angular_velocity;         // [rad/s] Current angular velocity. Magnitude gives speed clockwise about direction
        VECTOR ned_angular_acceleration;     // [rad/s2] Current angular acceleration. Magnitude gives accel clockwise about direction

        long num_polys; // [unitless]
        MS_POLYGON *ms_poly_array;
        double length, width, height;        // [m] calculated, if polys exist.

        char *openflight;                 // OpenFlight Geometry file

        long nmatls;                   // number of materials in the mp_table array
        MATL_PROP_TABLE *mp_table;           // array of material property data (BRDF and areal RCS)

        SPIRITS_TABLE *spirits_table;        // SPIRITS surface temp
        PLUME_FLOWFIELD *spf_table;          // SPF plume flowfield
        PLUME_RADIANCE_MAP *spurc_table;     // SPURC plume radiance projection LUT
        MUSES_TABLE *muses_table;            // Muses surface temp
        SCATTER_TABLE *scat_table;           // scatter center table for all the sensor center frequencies to be played
        SCATTER_VECTOR_TABLE *scat_vector_table;// scatter center table for all the sensor center frequencies to be played
        RCS_TABLE *rcs_table;             // holder for polarized RCS 2D LUT
      USCSET *uscset;                     // JRM Universal Scatter Center set 
        SMOKE_PROJECTION_MAP *combic_table;     // holds smoke cloud projection for given FOV
      PARTICLEINPUT *pinput;              // Particle System Input
      PARTICLESYSTEM *psystem;            // Particle System Parameters (derived from pinput)

      TARGET *target;                     // Target Properties
      DATALINK_PARTICIPANT *datalink;        // Datalink
      RF_JAMMER *rfjammer;             // RF Jammer
      RF_DECOY *rfdecoy;                  // RF Chaff/decoy 

        OLD_RCS_TABLE *old_rcs_table;         // Let's do something about this soon, huh?
        double rcs_sigma;                 // [unitless] Unused as of 020715. Let's get rid of this too.

        // Note: the following is used only if UseRadImage=TRUE :
        jrmbool UseRadImage;                    // TRUE=Uses radiance image BMP files (for ComputeAcquireParams only as of 12/12/02)
        char rcs_file[SIGSIM_STRING_SIZE];            // Radar Cross section file
        char front_rad_file[SIGSIM_STRING_SIZE];      // Front radiance image file
        char back_rad_file[SIGSIM_STRING_SIZE];       // Back radiance image file
        char left_rad_file[SIGSIM_STRING_SIZE];       // Left radiance image file
        char right_rad_file[SIGSIM_STRING_SIZE];      // Right radiance image file
        char up_rad_file[SIGSIM_STRING_SIZE];         // Up radiance image file
        char down_rad_file[SIGSIM_STRING_SIZE];       // Down radiance image file
        double radf, radb, radl, radr, radu, radd;    // [W/cm2] image ave emittances
        double rmaxf, rmaxb, rmaxl, rmaxr, rmaxu, rmaxd;// [W/cm2] image max emittances
        double rminf, rminb, rminl, rminr, rminu, rmind;// [W/cm2] image min emittances
        double axf,bxf,axb,bxb,axl,bxl,axr,bxr,axu,bxu,axd,bxd; // [um] image wavebands

    } OBJECT;

    typedef struct
    {
        long polyID;    // ID of polygon hit
        VECTOR norm_g;  // Normal in global space
        jrmbool inout;  // TRUE = ray enters face, FALSE = ray exits face
        VECTOR v1,v2,v3;// Vertices in global space
        VECTOR hit_g;   // Position of hitpoint in global space
        VECTOR hit_b;   // Position of hitpoint in body space
        VECTOR hit_v;   // Distances from vertices {v1, v2, v3}
        double dist; // Distance along global +x from global origin.
    } OBJHIT;        // Object hitpoint


    /* ------------------- BASIC VERTEX FUNCTIONS  ---------------------- */
    SIGSIM49_API VERTEX Makevertex(double x, double y, double z);
    SIGSIM49_API VECTOR Vertex2Vector(VERTEX X);
    SIGSIM49_API VERTEX Vector2Vertex(VECTOR V);

    /* ---------- BASIC MULTI-VERTEX / POLYGON FUNCTIONS -------------------- */
    SIGSIM49_API double area(VERTEX P1, VERTEX P2, VERTEX P3);
    SIGSIM49_API double determ(VERTEX P1, VERTEX P2);
    SIGSIM49_API VECTOR coss(VERTEX P1, VERTEX P2, VERTEX P3); /* Auxiliary function calculating normal vector to plane passing through three points */
    SIGSIM49_API double polyarea(MS_POLYGON *polyin);

    /* ------------------ ALLOCATION / DEALLOCATION / COMBINATION ----------------------- */
    SIGSIM49_API MS_POLYGON* AllocateProjPolyArray(OBJECT *obj, long size);
    SIGSIM49_API int DeallocateProjPolyArray(MS_POLYGON** obj);

    // AllocateObjects allocates (but does not fill) an array of OBJECTs of length nobjects.
    // Inputs : nobjects = number of OBJECTs to be allocated.
    // Outputs: Object = Pointer to array of OBJECTs to be allocated.
    //         UseRadImage will be set to FALSE by default.
    //         ms_poly_array and rcs_table will be NULL by default.
    // Returns: SIGSIM_MEMORY_ALLOCATION_ERROR if Object array already allocated or otherwise cannot be allocated.
    //         SIGSIM_SUCCESS on successful completion.  
    SIGSIM49_API int AllocateObjects(int nobjects, OBJECT **Object); // Allocates general array of objects

    // AllocateObjectArray allocates (but does not fill) an array of OBJECTs of length num_objects, and also allocates the ms_poly_array for each.
    // Inputs : num_objects = number of OBJECTs to be allocated.
    //         polys_per_object = array of integers, each specifying the number of polygons in the corresponding OBJECT's ms_poly_array.
    // Outputs: object = Pointer to array of OBJECTs to be allocated.
    //         UseRadImage will be set to FALSE by default.
    //         rcs_table will be NULL by default.
    // Returns: SIGSIM_MEMORY_ALLOCATION_ERROR if Object array or ms_poly_array already allocated or otherwise cannot be allocated.
    //         SIGSIM_SUCCESS on successful completion.  
    SIGSIM49_API int AllocateObjectArray(int num_objects, int *polys_per_object, OBJECT **object);

    // Free_Objects frees the memory allocated to an array of OBJECTs.
    // Inputs :   object = pointer to array of OBJECTs
    //         nobjects = size of object array
    // Returns:   SIGSIM_FUNCTION_FAILURE if object array is already NULL,
    //         SIGSIM_SUCCESS upon successful completion.
    SIGSIM49_API int Free_Objects(OBJECT **object, int nobjects);

    // Free_Object_Arrays frees the memory allocated to the arrays within an array of OBJECTs,
    // but not that associated with the object array itself.
    // Inputs :   object = array of OBJECTs
    //         nobjects = size of object array
    // Returns:   SIGSIM_FUNCTION_FAILURE if object array is already NULL,
    //         SIGSIM_SUCCESS upon successful completion.
    SIGSIM49_API int Free_Object_Arrays(OBJECT *object, int nobjects);


    // AddToObject() modifies composite OBJECT to add new OBJECTs according to placement/orientation in corresponding TRACK array.
    // Inputs :   composite = pointer to pre-allocated OBJECT to be added to.
    //         nobjects = number of OBJECTs in object array to be added. Should also equal number of TRACKs in track array.
    //         object = array of OBJECTs to be added to composite OBJECT.
    //         track = array of TRACKs on a one-to-one correspondence with the object array. Each TRACK gives the position and orientation of the corresponding OBJECT to be added, as measured in the composite OBJECT's body FRD system.
    // Returns:   The number of polygons in the final composite OBJECT's ms_poly_array, after all OBJECTs have been added. int i;
    SIGSIM49_API long AddToObject(OBJECT *composite, int nobjects, OBJECT *object, TRACK *track);

    /* ----------------- COORDINATE TRANSFORMATIONS ----------------------------- */
    SIGSIM49_API int MSPolygonRFU2FRD(MS_POLYGON *polyin, int npolys);
    SIGSIM49_API int GetTargetSensorNEDProjPolygons(OBJECT *obj, SENSOR *sens, ellipsoid E,MS_POLYGON** proj, int* nmb_tr);
    // Translates object's polygons to sensor NED system.
    // "obj" contains the polygons to be translated.
    // "proj" is the output array of translated NED polygons
    // "nmb_tr" is the number of polygons in the output "proj" array.
    SIGSIM49_API MS_POLYGON fromNED2SensorPlane(MS_POLYGON mElement, VECTOR N);
    // Inputs single polygon, and vector toward sensor FRONT direction,
    // and outputs that polygon as seen in new coordinate system defined by :
    //      new xhat = sensor RIGHT (+y)
    //      new yhat = sensor UP (-z)
    //      new zhat = 0.0 [in sensor FRONT direction (+x)]

    /* ----------------------- PROJECTIONS AND INTERSECTIONS ----------------------- */
    SIGSIM49_API void GetObjectBoundingBox(OBJECT *obj, VECTOR FRDright, VECTOR FRDdown, double *up, double *down, double *left, double *right);
    SIGSIM49_API int PolyNirt(OBJECT *object, TRACK track, OBJHIT **hit);
    // PolyNirt inputs an object placed at a certain track.position within a global space at arbitrary track.orientation.
    // A ray is then fired along the x-axis of the global space, and intersects the object at certain points.
    // PolyNirt allocates and returns an array of nhit "OBJHIT" structures containing the intersection data.
    // NOTE : Assumes track.position is in same units as poly vertices !!!
    SIGSIM49_API int Free_OBJHITs(OBJHIT *hits);
    SIGSIM49_API int GetTargetNEDBoundingBox(OBJECT *obj, VECTOR Rtarget, int *nvecs, VECTOR *corner);
    SIGSIM49_API int GetBackgroundHits(ellipsoid E, OBJECT obj, VECTOR Rtarget, double delta, int ngeoC, VECTOR *TNED, GEOCENTRIC_LOCATION *geoC);
    SIGSIM49_API int KLUDGE_SensorTransverseVecsInObjectNED(ellipsoid E, SENSOR sens, OBJECT obj, VECTOR RtargetNED, VECTOR *right, VECTOR *down);
    SIGSIM49_API int KLUDGE_SensorTransverseVecsInObjectNED_P2P(ellipsoid E, FOV sens, GEOCENTRIC_LOCATION obj, VECTOR RtargetNED, VECTOR *right, VECTOR *down);
    SIGSIM49_API int TargetTransverseDimensions(VECTOR right, VECTOR down, int nvecs, VECTOR *corner, double *horizontal, double *vertical);
    SIGSIM49_API void ObjectDimensions(OBJECT *objectin);

    /* -------------------- RADIANCE CALCULATION -------------------------- */
    SIGSIM49_API double computerad(OBJECT *objectin, SENSOR *sens, VECTOR direction);

    // SetMinMaxObjectRadiances() can be used to set the OBJECT structure minimum and maximum radiances and passbands for use with the UseRadImage switch,
    // but note that all passbands will be the SAME, all maximum radiances will be the SAME, and all minimum radiances will be the SAME, for all faces of the object cube.
    // For specification of different parameters for each face, the user is expected to either use GetScenario, or use a call to rademit_approx as follows:
    // Given a passband ax and bx [in microns], and a face temperature T [in degK], the associated radiance is given by:
    //      double itd;
    //      rad = rademit_approx(ax, bx, T, 10, &itd);
    // This should be done for Tmin and Tmax, for each face.
    //
    // Inputs: object = pointer to OBJECT whose passband and radiances are to be calculated.
    //         bmpax = wavelength [um] of start of passband associated with the image.
    //         bmpbx = wavelength [um] of end   of passband associated with the image.
    //         bmptlo = temperature [degC] of start of image dynamic range.
    //         bmpthi = temperature [degC] of end   of image dynamic range.
    // Outputs:   Passband starting wavelengths object->{axf,axb,axl,axr,axu,axd}.
    //         Passband ending     wavelengths object->{bxf,bxb,bxl,bxr,bxu,bxd}.
    //         Minimum radiances object->{rminf, rminb, rminl, rminr, rminu, rmind}.
    //         Maximum radiances object->{rmaxf, rmaxb, rmaxl, rmaxr, rmaxu, rmaxd}.
    // Returns:   SIGSIM_SUCCESS upon successful completion.
    SIGSIM49_API int SetMinMaxObjectRadiances(OBJECT *object, double bmpax, double bmpbx, double bmptlo, double bmpthi);

    // FillObjectRCSandRadianceFromImages() fills OBJECT RCS table and radiance images.
    // If object->UseRadImage=TRUE, then object->rcs_file will be read into 
    // object->old_rcs_table, and object->xxx_rad_file(s) will be read and converted
    // to radiances stored in object->radx. Here 'xxx' and 'x' denote a particular face {u,d,r,l,f,b}.
    // Inputs :   sigsim_data_dir = string containing the name of the main data directory (this routine will look for the object/rcs subdirectory).
    //         object = pointer to OBJECT whose RCS and radiance tables are to be filled.
    // Uses:   object->rcs_file
    //         object->{front,back,left,right,up,down}_rad_file.
    //         object->{rmaxf,rmaxb,rmaxl,rmaxr,rmaxu,rmaxd}
    //         object->{rminf,rminb,rminl,rminr,rminu,rmind}
    // Outputs: object->old_rcs_table
    //         object->{radf,radb,radl,radr,radu,radd}
    // Returns: SIGSIM_FILE_NOT_FOUND if sigsim_data_dir/object/rcs/object->rcs_file is not found or can't be read.
    //         SIGSIM_FILE_NOT_FOUND*(-1) if sigsim_data_dir/object/bmp/object->{front,back,left,right,up,down}_rad_file is not found or can't be read.
    //         SIGSIM_SUCCESS upon successful completion.
    SIGSIM49_API int FillObjectRCSandRadianceFromImages(char *sigsim_data_dir, OBJECT *object);

    SIGSIM49_API double ObjectRadianceFromImage(OBJECT *object, SENSOR *sens, VECTOR NED);

   SIGSIM49_API int UpdateObjectParticleEffects(char *sigsim_atm_dir, OBJECT *object, METIN *metin);

   SIGSIM49_API int PrintParticleSystem(OBJECT *object, SPECTRAL_DOMAIN *spectrum);


    /* -------------------------- OBJECT CREATION --------------------------- */
    SIGSIM49_API int CreateCone(int nmb_faces, double length, double angle, VERTEX base_center, VECTOR dir, OBJECT* cone);
    // "nmb_faces" specifies the number of MS_POLYGONs to use in construction of the cone.
    // "length" is in meters
    // "angle" is in radians and is half of the angle at the cone apex
    // "base_center" is in meters, and refers to the location of the center of the cone base relative to the object local origin in object-local FRD.
    // "dir" is a vector specifying the direction from base center to the apex vertex in object-local FRD.
    SIGSIM49_API int CreateCyl(int nmb_faces, double length, double radius, VERTEX center, VECTOR dir, OBJECT* cyl);
    // "nmb_faces" specifies the number of MS_POLYGONs to use in construction of the cylinder.
    // "length" is in meters
    // "radius" is in meters
    // "center" is in meters, and refers to the location of the center of the cylinder relative to the object local origin in object-local FRD.
    // "dir" is a vector specifying the direction of the cylinder axis in object-local FRD, and has bi-directional ambiguity.
    SIGSIM49_API int BoxTestObject(OBJECT *object, double length, double width, double height, double patch);
    SIGSIM49_API double CreatePlane(double length_x, double width_y, VECTOR default_normal, long default_ms_index, double degK, MS_POLYGON *poly1, MS_POLYGON *poly2);

    /* --------------- IMPORT / EXPORT -------------------------- */
    SIGSIM49_API int Geo2MSPolygon(char *sigsim_data_dir, char *objgeo_file, MS_POLYGON **returnpoly, long *npolys);
    SIGSIM49_API int AppendGeo2MSPolygon(char *sigsim_data_dir, char *objgeo_file, MS_POLYGON **returnpoly, long *npolys);
    SIGSIM49_API int MSPolygon2Geo(char *sigsim_data_dir, char *objgeo_file, MS_POLYGON **returnpoly, long *npolys);

    /* --------------- PHOTOGRAMMETRY --------------------------- */

    typedef struct
    {
        VECTOR V;       // vertex
        int p1,p2;      // self-plane identifiers
        int pi;         // other-plane identifier
        int f;          // self-frustrum identifier
    }   INTERSECT;

    typedef struct
    {
        VECTOR V;       // observer position
        VECTOR ul;      // upper-left unit direction
        VECTOR ur;      // upper-right unit direction
        VECTOR lr;      // lower-right unit direction
        VECTOR ll;      // lower-left unit direction
    }   FRUSTUM;        // frustum definition. Plane IDs : 0=upper, 1=right, 2=lower, 3=left

    typedef struct
    {
        INTERSECT *a;
        INTERSECT *b;
        int p1,p2;      // plane identifiers of form 4*f+p (so that 0-3 are from A and 4-7 are from B in GetFrustumIntersects)
        int t;          // triangle index
    }   EDGE;

    typedef struct
    {
        int lh, lv;             // left-image pixel location
        int rh, rv;             // right-image pixel location
    }   PIXEL_CORRELATION;

    SIGSIM49_API jrmbool GetLinePlaneIntersectPoint(VECTOR S, VECTOR L, VECTOR V, VECTOR CL, VECTOR CR, VECTOR *P);
    SIGSIM49_API VECTOR RotateVectorToPixelCorner(FOV fov, int hpixel, int vpixel, jrmbool up, jrmbool left);
    SIGSIM49_API void FillPixelFrustumDirections(FOV fov, int hpixel, int vpixel, FRUSTUM *F);
    SIGSIM49_API void FillFOVFrustumDirections(FOV fov, FRUSTUM *F);
    SIGSIM49_API int AddIntersect(int *NI, INTERSECT **I, INTERSECT toadd);
    SIGSIM49_API void RidIntersect(INTERSECT **I, int *NI, int which);
    SIGSIM49_API jrmbool CompareIntersects(INTERSECT *A, INTERSECT *B);
    SIGSIM49_API void RidDuplicateIntersects(INTERSECT **I, int *NI);
    SIGSIM49_API int FreeIntersectArray(INTERSECT **I);
    SIGSIM49_API int GetFrustumIntersects(FRUSTUM A, FRUSTUM B, INTERSECT **I);
    SIGSIM49_API int AddEdge(int *NE, EDGE **E, INTERSECT *a, INTERSECT *b, int p1, int p2);
    SIGSIM49_API void RidEdge(EDGE **E, int *NE, int which);
    SIGSIM49_API jrmbool CompareEdges(EDGE *A, EDGE *B);
    SIGSIM49_API void RidDuplicateEdges(EDGE **E, int *NE);
    SIGSIM49_API int FreeEdgeArray(EDGE **E);
    SIGSIM49_API int CreateVolumeEdges(INTERSECT *I, int NI, EDGE **E);
    SIGSIM49_API int CreateFinalFacetization(EDGE **E, int *NE);
    SIGSIM49_API int AddMSPolygon(int *NP, MS_POLYGON **P, INTERSECT *I1, INTERSECT *I2, INTERSECT *I3);
    SIGSIM49_API int CreateMSPolygonsFromEdges(EDGE *E, int NE, MS_POLYGON **P, int *NP);
    SIGSIM49_API void CheckSurfaceNormals(MS_POLYGON *P, int NP);
    SIGSIM49_API void RidPoly(MS_POLYGON **P, int *NP, int which);
    SIGSIM49_API jrmbool CompareVertices(VERTEX A, VERTEX B);
    SIGSIM49_API jrmbool ComparePolys(MS_POLYGON *A, MS_POLYGON *B);
    SIGSIM49_API void RidDuplicatePolys(MS_POLYGON **P, int *NP);
    SIGSIM49_API void CenterMSPolyArray(MS_POLYGON *P, int NP);
    SIGSIM49_API EULERzyx Ened2Ened(ellipsoid E, GEOCENTRIC_LOCATION CA, EULERzyx OA, GEOCENTRIC_LOCATION CB);
    SIGSIM49_API void GetNecessaryFOVExtentsToViewIntersects(INTERSECT *I, int NI, VECTOR viewposition, EULERzyx orientation, double *vfov, double *hfov);
    SIGSIM49_API double TranslateFOVsToCommonNEDSystem(FOV *A, FOV *B, ellipsoid E, FOV *mid);
    SIGSIM49_API double CreatePhotogrammetricMSPolyArray(FOV left, FOV right, ellipsoid e, PIXEL_CORRELATION *C, int NC, MS_POLYGON **ALLP, int *NALLP, FOV *center);
    SIGSIM49_API void FreePixelCorrelationArray(PIXEL_CORRELATION **C);
    SIGSIM49_API int AddPixelCorrelation(int *NC, PIXEL_CORRELATION **C, int lh, int lv, int rh, int rv);
    SIGSIM49_API double PixelCorrelation(RGB A, RGB B);
    SIGSIM49_API double SubImagePairCorrelation(RGB *left, RGB *right, iVEC_HV lul, iVEC_HV rul, int hsubsize, int vsubsize, iVEC_HV leftfullsize, iVEC_HV rightfullsize);
    SIGSIM49_API int GetImagePairPixelCorrelation(RGB *left, iVEC_HV leftsize, RGB *right, iVEC_HV rightsize, int windowsize, double corthresh, PIXEL_CORRELATION **C, int *NC);
    SIGSIM49_API int AdjustLeftSensorAccordingToPixelCorrelationOffset(FOV *left, FOV right, PIXEL_CORRELATION *C, int NC);
    SIGSIM49_API int WriteCorrelationFPFImage(char *filepath, RGB *left, int hsize, int vsize, PIXEL_CORRELATION *C, int NC);
    SIGSIM49_API int WriteImagePairCorrelationsToFile(char *filepath, PIXEL_CORRELATION *C, int NC);
    SIGSIM49_API int ReadImagePairCorrelationsFromFile(char *filepath, PIXEL_CORRELATION **C, int *NC);
    SIGSIM49_API int ReadBMPIntoRGBArray(char *filepath, RGB **image, iVEC_HV *size, unsigned short *bit_depth);
    SIGSIM49_API int WriteBMPFromRGBArray(char *filepath, RGB *image, iVEC_HV size, unsigned short bit_depth);
    SIGSIM49_API int ConvertDoubleArrayToRGB(double *d, RGB **rgb, int size);
    SIGSIM49_API int ConvertRGBArrayToDouble(double **d, RGB *rgb, int size);
   SIGSIM49_API void FreeRGBArray(RGB **rgb);

    /* --------------- RENDERING --------------------------- */

   SIGSIM49_API int RenderObjectToFile(char *basename, OBJECT *object, METIN *metin, SENSOR *sens, unsigned short bit_depth);



#ifdef __cplusplus
}
#endif

#endif //OBJECTS_H_