cartesian.h

Go to the documentation of this file.

/* --------------------------------------------------------------------
Copyright (C) 2009 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 CARTESIAN_H
#define CARTESIAN_H
#include "rave_proj.h"
#include "projection.h"
#include "area.h"
#include "rave_object.h"
#include "rave_types.h"
#include "rave_list.h"
#include "raveobject_list.h"
#include "rave_attribute.h"
#include "rave_field.h"
#include "cartesianparam.h"
 
typedef struct _Cartesian_t Cartesian_t;
 
extern RaveCoreObjectType Cartesian_TYPE;
 
int Cartesian_setTime(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getTime(Cartesian_t* cartesian);
 
int Cartesian_setDate(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getDate(Cartesian_t* cartesian);
 
int Cartesian_setStartTime(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getStartTime(Cartesian_t* cartesian);
 
int Cartesian_setStartDate(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getStartDate(Cartesian_t* cartesian);
 
int Cartesian_setEndTime(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getEndTime(Cartesian_t* cartesian);
 
int Cartesian_setEndDate(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getEndDate(Cartesian_t* cartesian);
 
int Cartesian_setSource(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getSource(Cartesian_t* cartesian);
 
int Cartesian_setProdname(Cartesian_t* cartesian, const char* value);
 
const char* Cartesian_getProdname(Cartesian_t* cartesian);
 
int Cartesian_setObjectType(Cartesian_t* self, Rave_ObjectType type);
 
Rave_ObjectType Cartesian_getObjectType(Cartesian_t* self);
 
void Cartesian_setXSize(Cartesian_t* self, long xsize);
 
void Cartesian_setYSize(Cartesian_t* self, long ysize);
 
long Cartesian_getXSize(Cartesian_t* cartesian);
 
long Cartesian_getYSize(Cartesian_t* cartesian);
 
void Cartesian_setAreaExtent(Cartesian_t* cartesian, double llX, double llY, double urX, double urY);
 
void Cartesian_getAreaExtent(Cartesian_t* cartesian, double* llX, double* llY, double* urX, double* urY);
 
int Cartesian_getExtremeLonLatBoundaries(Cartesian_t* self, double* ulLon, double* ulLat, double* lrLon, double* lrLat);
 
void Cartesian_setXScale(Cartesian_t* cartesian, double xscale);
 
double Cartesian_getXScale(Cartesian_t* cartesian);
 
void Cartesian_setYScale(Cartesian_t* cartesian, double yscale);
 
double Cartesian_getYScale(Cartesian_t* cartesian);
 
int Cartesian_setProduct(Cartesian_t* cartesian, Rave_ProductType type);
 
Rave_ProductType Cartesian_getProduct(Cartesian_t* cartesian);
 
double Cartesian_getNodata(Cartesian_t* self);
 
double Cartesian_getUndetect(Cartesian_t* self);
 
double Cartesian_getLocationX(Cartesian_t* cartesian, long x);
 
double Cartesian_getLocationY(Cartesian_t* cartesian, long y);
 
long Cartesian_getIndexX(Cartesian_t* cartesian, double x);
 
long Cartesian_getIndexY(Cartesian_t* cartesian, double y);
 
int Cartesian_getLonLatFromXY(Cartesian_t* self, int x, int y, double* lon, double* lat);
 
int Cartesian_getLonLatFromXYLocation(Cartesian_t* self, double x, double y, double* lon, double* lat);
 
int Cartesian_getXYFromLonLat(Cartesian_t* self, double lon, double lat, int* x, int* y);
 
int Cartesian_getXYLocationFromLonLat(Cartesian_t* self, double lon, double lat, double* x, double* y);
 
int Cartesian_setDefaultParameter(Cartesian_t* self, const char* name);
 
const char* Cartesian_getDefaultParameter(Cartesian_t* self);
 
int Cartesian_setProjection(Cartesian_t* cartesian, Projection_t* projection);
 
Projection_t* Cartesian_getProjection(Cartesian_t* cartesian);
 
const char* Cartesian_getProjectionString(Cartesian_t* cartesian);
 
int Cartesian_setValue(Cartesian_t* cartesian, long x, long y, double v);
 
int Cartesian_setConvertedValue(Cartesian_t* cartesian, long x, long y, double v);
 
RaveValueType Cartesian_getValue(Cartesian_t* cartesian, long x, long y, double* v);
 
RaveValueType Cartesian_getConvertedValue(Cartesian_t* cartesian, long x, long y, double* v);
 
RaveValueType Cartesian_getValueAtLocation(Cartesian_t* cartesian, double lx, double ly, double* v);
 
RaveValueType Cartesian_getConvertedValueAtLocation(Cartesian_t* cartesian, double lx, double ly, double* v);
 
RaveValueType Cartesian_getConvertedValueAtLonLat(Cartesian_t* cartesian, double lon, double lat, double* v);
 
int Cartesian_getQualityValueAtLocation(Cartesian_t* cartesian, double lx, double ly, const char* name, double *v);
 
int Cartesian_getConvertedQualityValueAtLocation(Cartesian_t* cartesian, double lx, double ly, const char* name, double *v);
 
int Cartesian_getQualityValueAtLonLat(Cartesian_t* cartesian, double lon, double lat, const char* name, double *v);
 
int Cartesian_getConvertedQualityValueAtLonLat(Cartesian_t* cartesian, double lon, double lat, const char* name, double *v);
 
void Cartesian_init(Cartesian_t* cartesian, Area_t* area);
 
RaveValueType Cartesian_getMean(Cartesian_t* cartesian, long x, long y, int N, double* v);
 
int Cartesian_isTransformable(Cartesian_t* cartesian);
 
int Cartesian_addAttribute(Cartesian_t* cartesian, RaveAttribute_t* attribute);
 
int Cartesian_addAttributeVersion(Cartesian_t* cartesian, RaveAttribute_t* attribute, RaveIO_ODIM_Version version);
 
RaveAttribute_t* Cartesian_getAttribute(Cartesian_t* cartesian, const char* name);
 
RaveAttribute_t* Cartesian_getAttributeVersion(Cartesian_t* cartesian, const char* name, RaveIO_ODIM_Version version);
 
RaveList_t* Cartesian_getAttributeNames(Cartesian_t* cartesian);
 
RaveList_t* Cartesian_getAttributeNamesVersion(Cartesian_t* cartesian, RaveIO_ODIM_Version version);
 
RaveObjectList_t* Cartesian_getAttributeValues(Cartesian_t* cartesian);
 
RaveObjectList_t* Cartesian_getAttributeValuesVersion(Cartesian_t* cartesian, RaveIO_ODIM_Version version);
 
int Cartesian_hasAttribute(Cartesian_t* cartesian, const char* name);
 
int Cartesian_addQualityField(Cartesian_t* cartesian, RaveField_t* field);
 
RaveField_t* Cartesian_getQualityField(Cartesian_t* cartesian, int index);
 
int Cartesian_getNumberOfQualityFields(Cartesian_t* cartesian);
 
void Cartesian_removeQualityField(Cartesian_t* cartesian, int index);
 
RaveObjectList_t* Cartesian_getQualityFields(Cartesian_t* cartesian);
 
RaveField_t* Cartesian_getQualityFieldByHowTask(Cartesian_t* cartesian, const char* name);
 
RaveField_t* Cartesian_findQualityFieldByHowTask(Cartesian_t* self, const char* value);
 
int Cartesian_addParameter(Cartesian_t* self, CartesianParam_t* param);
 
CartesianParam_t* Cartesian_getParameter(Cartesian_t* self, const char* name);
 
int Cartesian_hasParameter(Cartesian_t* self, const char* name);
 
void Cartesian_removeParameter(Cartesian_t* self, const char* name);
 
int Cartesian_getParameterCount(Cartesian_t* self);
 
RaveList_t* Cartesian_getParameterNames(Cartesian_t* self);
 
CartesianParam_t* Cartesian_createParameter(Cartesian_t* self, const char* quantity, RaveDataType type, double datavalue);
#endif