composite_utils.h

Go to the documentation of this file.

/* --------------------------------------------------------------------
Copyright (C) 2025 Swedish Meteorological and Hydrological Institute, SMHI,
 
This file is part of RAVE.
 
RAVE is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
 
RAVE is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License
along with RAVE.  If not, see <http://www.gnu.org/licenses/>.
------------------------------------------------------------------------*/
#ifndef COMPOSITE_UTILS_H
#define COMPOSITE_UTILS_H
#include "cartesian.h"
#include "cartesianvolume.h"
#include "compositearguments.h"
#include "rave_attribute.h"
#include "rave_object.h"
#include "rave_types.h"
#include "raveobject_list.h"
#include "raveobject_hashtable.h"
#include "projection_pipeline.h"
#include <strings.h>

typedef int(*composite_utils_getPolarValueAtPosition_fun)(void* extradata, CompositeArguments_t* arguments, RaveCoreObject* object, const char* quantity, PolarNavigationInfo* navinfo, const char* qiFieldName, RaveValueType* otype, double* ovalue, double* qivalue);

typedef struct CompositeUtilValue_t {
  RaveValueType vtype; 
  double value;       
  double mindist;     
  double radardist;   
  int radarindex;     
  const char* name;   
  PolarNavigationInfo navinfo; 
  CartesianParam_t* parameter; 
  double qivalue;     
  composite_utils_getPolarValueAtPosition_fun getPolarValueAtPosition; 
  void* extradata; 
} CompositeUtilValue_t;

typedef struct CompositeRaveObjectBinding_t {
  RaveCoreObject* object; 
  ProjectionPipeline_t* pipeline; 
  OdimSource_t* source; 
} CompositeRaveObjectBinding_t;

typedef struct CompositeQualityFlagSettings_t {
  char* qualityFieldName; 
  RaveDataType datatype; 
  double offset; 
  double gain; 
} CompositeQualityFlagSettings_t;

typedef struct CompositeQualityFlagDefinition_t {
  RAVE_OBJECT_HEAD 
  char* qualityFieldName;
  RaveDataType datatype;
  double offset;
  double gain;
} CompositeQualityFlagDefinition_t;

extern RaveCoreObjectType CompositeQualityFlagDefinition_TYPE;

CompositeQualityFlagDefinition_t* CompositeUtils_createQualityFlagDefinition(const char* qualityFieldName, RaveDataType datatype, double offset, double gain);

int CompositeUtils_registerQualityFlagDefinition(RaveObjectHashTable_t* qualityFlags, CompositeQualityFlagDefinition_t* definition);

int CompositeUtils_registerQualityFlagDefinitionFromArguments(RaveObjectHashTable_t* qualityFlags, const char* qualityFieldName, RaveDataType datatype, double offset, double gain);

 int CompositeUtils_registerQualityFlagDefinitionFromSettings(RaveObjectHashTable_t* qualityFlags, CompositeQualityFlagSettings_t* settings);

int CompositeUtils_isValidCartesianArguments(CompositeArguments_t* arguments);

Cartesian_t* CompositeUtils_createCartesianFromArguments(CompositeArguments_t* arguments);

CompositeUtilValue_t* CompositeUtils_createCompositeValues(CompositeArguments_t* arguments, Cartesian_t* cartesian, int* nentries);

void CompositeUtils_resetCompositeValues(CompositeArguments_t* arguments, CompositeUtilValue_t* cvalues, int nentries);

void CompositeUtils_freeCompositeValueParameters(CompositeUtilValue_t** cvalues, int nparam);

Projection_t* CompositeUtils_getProjection(RaveCoreObject* obj);

int CompositeUtils_getObjectSource(RaveCoreObject* obj, char* source, int nlen);

CompositeRaveObjectBinding_t* CompositeUtils_createRaveObjectBinding(CompositeArguments_t* arguments, Cartesian_t* cartesian, int* nobjects, OdimSources_t* sources);

void CompositeUtils_releaseRaveObjectBinding(CompositeRaveObjectBinding_t** arr, int nobjects);

void CompositeUtils_getQualityFlagSettings(CompositeQualityFlagSettings_t* settings, const char* flagname, double* offset, double* gain, RaveDataType* datatype);

 int CompositeUtils_addQualityFlagsToCartesian(CompositeArguments_t* arguments, Cartesian_t* cartesian, RaveObjectHashTable_t* definitions);

int CompositeUtils_addQualityFlagsToCartesianFromSettings(CompositeArguments_t* arguments, Cartesian_t* cartesian, CompositeQualityFlagSettings_t* settings);

int CompositeUtils_addGainAndOffsetToField(RaveField_t* field, double gain, double offset);

RaveField_t* CompositeUtils_createQualityField(const char* howtaskvaluestr, int xsize, int ysize, RaveDataType datatype, double gain, double offset);

int CompositeUtils_getPolarValueAtPosition(RaveCoreObject* obj, const char* quantity, PolarNavigationInfo* nav, const char* qiFieldName, RaveValueType* type, double* value, double* qualityValue);

int CompositeUtils_getPolarQualityValueAtPosition(RaveCoreObject* obj, const char* quantity, const char* qualityField, PolarNavigationInfo* nav, double* value);

int CompositeUtils_getVerticalMaxValue(
  RaveCoreObject* object,
  const char* quantity,
  const char* qiFieldName,
  double lon,
  double lat,
  RaveValueType* vtype,
  double* vvalue,
  PolarNavigationInfo* navinfo,
  double* qiv);
 
 

RaveList_t* CompositeUtils_cloneRaveListStrings(RaveList_t* inlist);
 
#endif /* COMPOSITE_UTILS_H */