Infrastructure for beam blocking in place hudson-beamb-1-SUCCESS
authorAnders Henja <anders@baltrad.eu>
Thu, 17 Nov 2011 09:13:10 +0000 (10:13 +0100)
committerAnders Henja <anders@baltrad.eu>
Thu, 17 Nov 2011 09:13:10 +0000 (10:13 +0100)
lib/bbtopography.c
lib/bbtopography.h
lib/beamblockagemap.c
lib/beamblockagemap.h
pybeamb/pybbtopography.c
pybeamb/pybbtopography.h
pybeamb/pybeamblockagemap.c
test/pytest/PyBBTopographyTest.py
test/pytest/PyBeamBlockageMapTest.py

index 514beea..d32862a 100644 (file)
@@ -31,7 +31,7 @@ along with beamb.  If not, see <http://www.gnu.org/licenses/>.
 /**
  * Represents the beam blockage topography
  */
-struct _BBTopograhy_t {
+struct _BBTopography_t {
   RAVE_OBJECT_HEAD /** Always on top */
   RaveData2D_t* data; /**< the data */
   double nodata; /**< the nodata */
@@ -45,9 +45,9 @@ struct _BBTopograhy_t {
 /**
  * Constructor.
  */
-static int BBTopograhy_constructor(RaveCoreObject* obj)
+static int BBTopography_constructor(RaveCoreObject* obj)
 {
-  BBTopograhy_t* self = (BBTopograhy_t*)obj;
+  BBTopography_t* self = (BBTopography_t*)obj;
   self->data = RAVE_OBJECT_NEW(&RaveData2D_TYPE);;
   self->nodata = -9999.0;
   self->ulxmap = 0.0;
@@ -69,9 +69,9 @@ error:
  * Destructor
  * @param[in] obj - object
  */
-static void BBTopograhy_destructor(RaveCoreObject* obj)
+static void BBTopography_destructor(RaveCoreObject* obj)
 {
-  BBTopograhy_t* self = (BBTopograhy_t*)obj;
+  BBTopography_t* self = (BBTopography_t*)obj;
   RAVE_OBJECT_RELEASE(self->data);
 }
 
@@ -81,10 +81,10 @@ static void BBTopograhy_destructor(RaveCoreObject* obj)
  * @param[in] srcobj - source object
  * @return 1 on success otherwise 0
  */
-static int BBTopograhy_copyconstructor(RaveCoreObject* obj, RaveCoreObject* srcobj)
+static int BBTopography_copyconstructor(RaveCoreObject* obj, RaveCoreObject* srcobj)
 {
-  BBTopograhy_t* this = (BBTopograhy_t*)obj;
-  BBTopograhy_t* src = (BBTopograhy_t*)srcobj;
+  BBTopography_t* this = (BBTopography_t*)obj;
+  BBTopography_t* src = (BBTopography_t*)srcobj;
   this->data = RAVE_OBJECT_CLONE(src->data);
   this->nodata = src->nodata;
   this->ulxmap = src->ulxmap;
@@ -106,86 +106,86 @@ error:
 /*@} End of Private functions */
 
 /*@{ Interface functions */
-void BBTopography_setNodata(BBTopograhy_t* self, double nodata)
+void BBTopography_setNodata(BBTopography_t* self, double nodata)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->nodata = nodata;
 }
 
-double BBTopography_getNodata(BBTopograhy_t* self)
+double BBTopography_getNodata(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->nodata;
 }
 
-void BBTopography_setXDim(BBTopograhy_t* self, double xdim)
+void BBTopography_setXDim(BBTopography_t* self, double xdim)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->xdim = xdim;
 }
 
-double BBTopography_getXDim(BBTopograhy_t* self)
+double BBTopography_getXDim(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->xdim;
 }
 
 
-void BBTopography_setYDim(BBTopograhy_t* self, double ydim)
+void BBTopography_setYDim(BBTopography_t* self, double ydim)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->ydim = ydim;
 }
 
-double BBTopography_getYDim(BBTopograhy_t* self)
+double BBTopography_getYDim(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->ydim;
 }
 
-void BBTopography_setUlxmap(BBTopograhy_t* self, double ulxmap)
+void BBTopography_setUlxmap(BBTopography_t* self, double ulxmap)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->ulxmap = ulxmap;
 }
 
-double BBTopography_getUlxmap(BBTopograhy_t* self)
+double BBTopography_getUlxmap(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->ulxmap;
 }
 
-void BBTopography_setUlymap(BBTopograhy_t* self, double ulymap)
+void BBTopography_setUlymap(BBTopography_t* self, double ulymap)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   self->ulymap = ulymap;
 }
 
-double BBTopography_getUlymap(BBTopograhy_t* self)
+double BBTopography_getUlymap(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return self->ulymap;
 }
 
-int BBTopography_createData(BBTopograhy_t* self, long ncols, long nrows, RaveDataType type)
+int BBTopography_createData(BBTopography_t* self, long ncols, long nrows, RaveDataType type)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_createData(self->data, ncols, nrows, type);
 }
 
-int BBTopography_setData(BBTopograhy_t* self, long ncols, long nrows, void* data, RaveDataType type)
+int BBTopography_setData(BBTopography_t* self, long ncols, long nrows, void* data, RaveDataType type)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_setData(self->data, ncols, nrows, data, type);
 }
 
-void* BBTopography_getData(BBTopograhy_t* self)
+void* BBTopography_getData(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_getData(self->data);
 }
 
-int BBTopography_setDatafield(BBTopograhy_t* self, RaveData2D_t* datafield)
+int BBTopography_setDatafield(BBTopography_t* self, RaveData2D_t* datafield)
 {
   int result = 0;
   RAVE_ASSERT((self != NULL), "self == NULL");
@@ -202,7 +202,7 @@ int BBTopography_setDatafield(BBTopograhy_t* self, RaveData2D_t* datafield)
   return result;
 }
 
-RaveData2D_t* BBTopography_getDatafield(BBTopograhy_t* self)
+RaveData2D_t* BBTopography_getDatafield(BBTopography_t* self)
 {
   RaveData2D_t* result = NULL;
 
@@ -216,42 +216,80 @@ RaveData2D_t* BBTopography_getDatafield(BBTopograhy_t* self)
   return result;
 }
 
-long BBTopography_getNcols(BBTopograhy_t* self)
+long BBTopography_getNcols(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_getXsize(self->data);
 }
 
-long BBTopography_getNrows(BBTopograhy_t* self)
+long BBTopography_getNrows(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_getYsize(self->data);
 }
 
-RaveDataType BBTopography_getDataType(BBTopograhy_t* self)
+RaveDataType BBTopography_getDataType(BBTopography_t* self)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_getType(self->data);
 }
 
-int BBTopography_getValue(BBTopograhy_t* self, long col, long row, double* v)
+int BBTopography_getValue(BBTopography_t* self, long col, long row, double* v)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_getValue(self->data, col, row, v);
 }
 
-int BBTopography_setValue(BBTopograhy_t* self, long col, long row, double value)
+int BBTopography_setValue(BBTopography_t* self, long col, long row, double value)
 {
   RAVE_ASSERT((self != NULL), "self == NULL");
   return RaveData2D_setValue(self->data, col, row, value);
 }
 
+BBTopography_t* BBTopography_concatX(BBTopography_t* self, BBTopography_t* other)
+{
+  BBTopography_t *result = NULL;
+  RaveData2D_t* dfield = NULL;
+
+  RAVE_ASSERT((self != NULL), "self == NULL");
+  if (other == NULL) {
+    RAVE_ERROR0("Trying to concatenate self with NULL");
+    return NULL;
+  }
+
+  if (BBTopography_getNrows(self) != BBTopography_getNrows(other) ||
+      BBTopography_getXDim(self) != BBTopography_getXDim(other) ||
+      BBTopography_getYDim(self) != BBTopography_getYDim(other)) {
+    RAVE_ERROR0("Can not concatenate two topography fields that doesn't have same nrows/xdim and ydim values");
+    return NULL;
+  }
+
+  dfield = RaveData2D_concatX(self->data, other->data);
+  if (dfield != NULL) {
+    result = RAVE_OBJECT_NEW(&BBTopography_TYPE);
+    if (result == NULL) {
+      RAVE_ERROR0("Failed to create topography field");
+    } else {
+      RAVE_OBJECT_RELEASE(result->data);
+      result->data = RAVE_OBJECT_COPY(dfield);
+      BBTopography_setNodata(result, BBTopography_getNodata(self));
+      BBTopography_setUlxmap(result, BBTopography_getUlxmap(self));
+      BBTopography_setUlymap(result, BBTopography_getUlymap(self));
+      BBTopography_setXDim(result, BBTopography_getXDim(self));
+      BBTopography_setYDim(result, BBTopography_getYDim(self));
+    }
+  }
+
+  RAVE_OBJECT_RELEASE(dfield);
+  return result;
+}
+
 /*@} End of Interface functions */
 
-RaveCoreObjectType BBTopograhy_TYPE = {
-    "BBTopograhy",
-    sizeof(BBTopograhy_t),
-    BBTopograhy_constructor,
-    BBTopograhy_destructor,
-    BBTopograhy_copyconstructor
+RaveCoreObjectType BBTopography_TYPE = {
+    "BBTopography",
+    sizeof(BBTopography_t),
+    BBTopography_constructor,
+    BBTopography_destructor,
+    BBTopography_copyconstructor
 };
index cec146e..2c4c0f1 100644 (file)
@@ -30,82 +30,82 @@ along with beamb.  If not, see <http://www.gnu.org/licenses/>.
 /**
  * Defines a beam blockage object
  */
-typedef struct _BBTopograhy_t BBTopograhy_t;
+typedef struct _BBTopography_t BBTopography_t;
 
 /**
  * Type definition to use when creating a rave object.
  */
-extern RaveCoreObjectType BBTopograhy_TYPE;
+extern RaveCoreObjectType BBTopography_TYPE;
 
 /**
  * Sets the nodata value
  * @param[in] self - self
  * @param[in] nodata - the nodata value
  */
-void BBTopography_setNodata(BBTopograhy_t* self, double nodata);
+void BBTopography_setNodata(BBTopography_t* self, double nodata);
 
 /**
  * Return the nodata value
  * @param[in] self - self
  * @return the nodata value
  */
-double BBTopography_getNodata(BBTopograhy_t* self);
+double BBTopography_getNodata(BBTopography_t* self);
 
 /**
  * Sets the x-scale in radians.
  * @param[in] self - self
  * @param[in] xdim - the x-scale (step-size) in radians
  */
-void BBTopography_setXDim(BBTopograhy_t* self, double xdim);
+void BBTopography_setXDim(BBTopography_t* self, double xdim);
 
 /**
  * Return the x-scale in radians.
  * @param[in] self - self
  * @return the x-scale (step size) in radians
  */
-double BBTopography_getXDim(BBTopograhy_t* self);
+double BBTopography_getXDim(BBTopography_t* self);
 
 /**
  * Sets the y-scale in radians.
  * @param[in] self - self
  * @param[in] ydim - the y-scale (step-size) in radians
  */
-void BBTopography_setYDim(BBTopograhy_t* self, double ydim);
+void BBTopography_setYDim(BBTopography_t* self, double ydim);
 
 /**
  * Return the y-scale in radians.
  * @param[in] self - self
  * @return the y-scale (step size) in radians
  */
-double BBTopography_getYDim(BBTopograhy_t* self);
+double BBTopography_getYDim(BBTopography_t* self);
 
 /**
  * Sets the upper left x-coordinate (longitude) in the topography map (in radians).
  * @param[in] self - self
  * @param[in] ulxmap - the upper left x-coordinate (longitude in radians))
  */
-void BBTopography_setUlxmap(BBTopograhy_t* self, double ulxmap);
+void BBTopography_setUlxmap(BBTopography_t* self, double ulxmap);
 
 /**
  * Return the upper left x-coordinate (longitude) in the topography map (in radians).
  * @param[in] self - self
  * @return the upper left x-coordinate (longitude in radians))
  */
-double BBTopography_getUlxmap(BBTopograhy_t* self);
+double BBTopography_getUlxmap(BBTopography_t* self);
 
 /**
  * Sets the upper left y-coordinate (latitude) in the topography map (in radians).
  * @param[in] self - self
  * @param[in] ulxmap - the upper left y-coordinate (latitude in radians))
  */
-void BBTopography_setUlymap(BBTopograhy_t* self, double ulymap);
+void BBTopography_setUlymap(BBTopography_t* self, double ulymap);
 
 /**
  * Return the upper left y-coordinate (latitude) in the topography map (in radians).
  * @param[in] self - self
  * @return the upper left y-coordinate (latitude in radians))
  */
-double BBTopography_getUlymap(BBTopograhy_t* self);
+double BBTopography_getUlymap(BBTopography_t* self);
 
 /**
  * Creates a empty data field
@@ -115,7 +115,7 @@ double BBTopography_getUlymap(BBTopograhy_t* self);
  * @param[in] type - the data type
  * @returns 1 on success otherwise 0
  */
-int BBTopography_createData(BBTopograhy_t* self, long ncols, long nrows, RaveDataType type);
+int BBTopography_createData(BBTopography_t* self, long ncols, long nrows, RaveDataType type);
 
 /**
  * Sets the data in the topography field.
@@ -126,13 +126,13 @@ int BBTopography_createData(BBTopograhy_t* self, long ncols, long nrows, RaveDat
  * @param[in] type - the data type
  * @returns 1 on success otherwise 0
  */
-int BBTopography_setData(BBTopograhy_t* self, long ncols, long nrows, void* data, RaveDataType type);
+int BBTopography_setData(BBTopography_t* self, long ncols, long nrows, void* data, RaveDataType type);
 /**
  * Returns a pointer to the internal data storage.
  * @param[in] self - self
  * @return the internal data pointer (NOTE! Do not release this pointer)
  */
-void* BBTopography_getData(BBTopograhy_t* self);
+void* BBTopography_getData(BBTopography_t* self);
 
 /**
  * Sets the rave data 2d field. This will create a clone from the provided data field.
@@ -140,7 +140,7 @@ void* BBTopography_getData(BBTopograhy_t* self);
  * @param[in] datafield - the data field to use (MAY NOT BE NULL)
  * @return 1 on success otherwise 0
  */
-int BBTopography_setDatafield(BBTopograhy_t* self, RaveData2D_t* datafield);
+int BBTopography_setDatafield(BBTopography_t* self, RaveData2D_t* datafield);
 
 /**
  * Returns the 2d field associated with this topography field. Note, it is a
@@ -149,28 +149,28 @@ int BBTopography_setDatafield(BBTopograhy_t* self, RaveData2D_t* datafield);
  * @param[in] field - self
  * @returns a clone of the internal data array on success otherwise NULL
  */
-RaveData2D_t* BBTopography_getDatafield(BBTopograhy_t* self);
+RaveData2D_t* BBTopography_getDatafield(BBTopography_t* self);
 
 /**
  * Returns the number of columns.
  * @param[in] self - self
  * @return the number of columns
  */
-long BBTopography_getNcols(BBTopograhy_t* self);
+long BBTopography_getNcols(BBTopography_t* self);
 
 /**
  * Returns the number of rows.
  * @param[in] self - self
  * @return the number of rows
  */
-long BBTopography_getNrows(BBTopograhy_t* self);
+long BBTopography_getNrows(BBTopography_t* self);
 
 /**
  * Returns the data type
  * @param[in] self - self
  * @return the data type
  */
-RaveDataType BBTopography_getDataType(BBTopograhy_t* self);
+RaveDataType BBTopography_getDataType(BBTopography_t* self);
 
 /**
  * Returns the value at the specified index.
@@ -180,7 +180,7 @@ RaveDataType BBTopography_getDataType(BBTopograhy_t* self);
  * @param[out] v - the data at the specified index
  * @return 1 on success, 0 otherwise
  */
-int BBTopography_getValue(BBTopograhy_t* self, long col, long row, double* v);
+int BBTopography_getValue(BBTopography_t* self, long col, long row, double* v);
 
 /**
  * Sets the value at specified position
@@ -189,6 +189,18 @@ int BBTopography_getValue(BBTopograhy_t* self, long col, long row, double* v);
  * @param[in] row - the row
  * @param[in] value - the value to be set at specified coordinate
  */
-int BBTopography_setValue(BBTopograhy_t* self, long col, long row, double value);
+int BBTopography_setValue(BBTopography_t* self, long col, long row, double value);
 
-#endif /* BEAMBLOCKAGE_H */
+/**
+ * Concatenates two topography fields horizontally with each other.
+ * The fields and others y-dimension must be the same as well as the data
+ * type. It is also necessary that ydim and xdim are the same. All other
+ * attribute values will be taken from the first field.
+ *
+ * @param[in] self - self
+ * @param[in] other - the field to contatenate
+ * @returns the concatenated field on success otherwise NULL
+ */
+BBTopography_t* BBTopography_concatX(BBTopography_t* self, BBTopography_t* other);
+
+#endif /* BBTOPOGRAPHY_H */
index 6ee05f4..ca32149 100644 (file)
@@ -51,19 +51,6 @@ struct _BeamBlockageMap_t {
  */
 #define DEG2RAD(deg) (deg*M_PI/180.0)
 
-/**
- * Internally used struct when reading header info from a TOPO30-file
- */
-typedef struct _map_info {
-  double ulxmap; /**< ulxmap */
-  double ulymap; /**< ulymap */
-  int nbits;     /**< nbits */
-  int nrows;     /**< nrows */
-  int ncols;     /**< ncols */
-  double xdim;   /**< xdim */
-  double ydim;   /**< ydim */
-} map_info;
-
 /*@{ Private functions */
 /**
  * Constructor.
@@ -116,12 +103,12 @@ error:
 }
 
 /**
- * Reads the gropo30 header file and populates the info struct
+ * Reads the gropo30 header file and populates the BBTopography instance with header information.
  * @param[in] self - self
  * @param[in] filename - the gtopo file
  * @param[in] info - the structure
  */
-static int BeamBlockageMapInternal_readTopographyHeader(BeamBlockageMap_t* self, const char* filename, map_info* info)
+static BBTopography_t* BeamBlockageMapInternal_readHeader(BeamBlockageMap_t* self, const char* filename)
 {
   /* Declaration of variables */
   char fname[1024];
@@ -129,12 +116,11 @@ static int BeamBlockageMapInternal_readTopographyHeader(BeamBlockageMap_t* self,
   char token[64];
   double f;
   FILE* fp = NULL;
-  int result = 0;
+  BBTopography_t *result = NULL, *field = NULL;
+  long ncols = 0, nrows = 0;
+  int nbits = 0;
 
   RAVE_ASSERT((self != NULL), "self == NULL");
-  RAVE_ASSERT((info != NULL), "info == NULL");
-
-  memset(info, 0, sizeof(map_info));
 
   if (filename == NULL) {
     goto done;
@@ -152,65 +138,91 @@ static int BeamBlockageMapInternal_readTopographyHeader(BeamBlockageMap_t* self,
     goto done;
   }
 
+  field = RAVE_OBJECT_NEW(&BBTopography_TYPE);
+  if (field == NULL) {
+    goto done;
+  }
+
   while (fgets(line, sizeof(line), fp) > 0) {
     if (sscanf(line, "%s %lf", token, &f) == 2) {
       if (strcmp(token, "NROWS") == 0) {
-        info->nrows = (int)f;
+        nrows = (long)f;
       } else if (strcmp(token, "NCOLS") == 0) {
-        info->ncols = (int)f;
+        ncols = (long)f;
       } else if (strcmp(token, "NBITS") == 0) {
-        info->nbits = (int)f;
+        nbits = (int)f;
       } else if (strcmp(token, "ULXMAP") == 0) {
-        info->ulxmap = f;
+        BBTopography_setUlxmap(field, f);
       } else if (strcmp(token, "ULYMAP") == 0) {
-        info->ulymap = f;
+        BBTopography_setUlymap(field, f);
       } else if (strcmp(token, "XDIM") == 0) {
-        info->xdim = f;
+        BBTopography_setXDim(field, f);
       } else if (strcmp(token, "YDIM") == 0) {
-        info->ydim = f;
+        BBTopography_setYDim(field, f);
       }
     }
   }
 
-  result = 1;
+  if (nbits != 0 && nbits != 16) {
+    RAVE_ERROR0("Only 16bit topography files supported");
+    goto done;
+  }
+
+  if (nrows == 0 || ncols == 0) {
+    RAVE_ERROR0("NROWS / NCOLS must not be 0");
+    goto done;
+  }
+
+  if (!BBTopography_createData(field, ncols, nrows, RaveDataType_SHORT));
+
+  result = RAVE_OBJECT_COPY(field);
 done:
+  RAVE_OBJECT_RELEASE(field);
   if (fp != NULL) {
     fclose(fp);
   }
   return result;
 }
 
-static RaveField_t* BeamBlockageMapInternal_readData(BeamBlockageMap_t* self, const char* filename, map_info* info)
+static int BeamBlockageMapInternal_fillData(BeamBlockageMap_t* self, const char* filename, BBTopography_t* field)
 {
+  int result = 0;
   FILE *fp = NULL;
   char fname[1024];
   short *tmp = NULL;
-  RaveField_t *result=NULL, *field = NULL;
-  long x, y;
+  long col, row;
+  long nrows = 0, ncols = 0;
   long nitems = 0;
 
   RAVE_ASSERT((self != NULL), "self == NULL");
-  RAVE_ASSERT((info != NULL), "info == NULL");
+  RAVE_ASSERT((field != NULL), "field == NULL");
 
   if (filename == NULL) {
     goto done;
   }
 
+  if (BBTopography_getDataType(field) != RaveDataType_SHORT) {
+    RAVE_ERROR0("Only supports reading of short data");
+    goto done;
+  }
+
   if (self->topodir != NULL) {
     sprintf(fname, "%s/%s.DEM", self->topodir, filename);
   } else {
     sprintf(fname, "%s.DEM", filename);
   }
 
-  nitems = info->ncols * info->nrows;
-
-  tmp = RAVE_MALLOC(sizeof(short)*nitems);
-  if (tmp == NULL) {
+  fp = fopen(fname, "rb");
+  if (fp == NULL) {
     goto done;
   }
 
-  fp = fopen(fname, "rb");
-  if (fp == NULL) {
+  nrows = BBTopography_getNrows(field);
+  ncols = BBTopography_getNcols(field);
+  nitems = nrows * ncols;
+  tmp = RAVE_MALLOC(sizeof(short)*nitems);
+  if (tmp == NULL) {
+    RAVE_ERROR0("Failed to allocate memory for data");
     goto done;
   }
 
@@ -218,24 +230,39 @@ static RaveField_t* BeamBlockageMapInternal_readData(BeamBlockageMap_t* self, co
     RAVE_WARNING0("Could not read correct number of items");
   }
 
-  field = RAVE_OBJECT_NEW(&RaveField_TYPE);
-  if (field == NULL || !RaveField_createData(field, info->ncols, info->nrows, RaveDataType_SHORT)) {
-    goto done;
+  for (col = 0; col < ncols; col++) {
+    for (row = 0; row < nrows; row++) {
+      BBTopography_setValue(field, col, row, (double)ntohs((short)(tmp[row*ncols + col])));
+    }
+  }
+
+  result = 1;
+done:
+  if (fp != NULL) {
+    fclose(fp);
   }
+  RAVE_FREE(tmp);
+  return result;
+}
+
+static BBTopography_t* BeamBlockageMapInternal_readTopography(BeamBlockageMap_t* self, const char* filename)
+{
+  BBTopography_t *result = NULL, *field = NULL;
 
-  for (x = 0; x < info->ncols; x++) {
-    for (y = 0; y < info->nrows; y++) {
-      RaveField_setValue(field, x, y, (double)ntohs((short)(tmp[y*info->ncols + x])));
+  RAVE_ASSERT((self != NULL), "self == NULL");
+
+  if (filename != NULL) {
+    field = BeamBlockageMapInternal_readHeader(self, filename);
+    if (field != NULL) {
+      if (!BeamBlockageMapInternal_fillData(self, filename, field)) {
+        goto done;
+      }
     }
   }
 
   result = RAVE_OBJECT_COPY(field);
 done:
-  RAVE_FREE(tmp);
   RAVE_OBJECT_RELEASE(field);
-  if (fp != NULL) {
-    fclose(fp);
-  }
   return result;
 }
 
@@ -246,12 +273,11 @@ done:
  * @param[in] d - maximum range of radar in meters
  * @returns flag corresponding to map to be read
  */
-RaveField_t* BeamBlockageMap_readTopography(BeamBlockageMap_t* self, double lat, double lon, double d)
+BBTopography_t* BeamBlockageMap_readTopography(BeamBlockageMap_t* self, double lat, double lon, double d)
 {
   double lat_e, lon_e, lat_w, lon_w, lat_n, lat_s;
   double earthRadius = 0.0;
-  RaveField_t *field = NULL, *result = NULL;
-  map_info minfo;
+  BBTopography_t *field = NULL, *result = NULL;
 
   RAVE_ASSERT((self != NULL), "self == NULL");
   earthRadius = PolarNavigator_getEarthRadius(self->navigator, lat);
@@ -272,64 +298,24 @@ RaveField_t* BeamBlockageMap_readTopography(BeamBlockageMap_t* self, double lat,
     goto done;
   } else if (RAD2DEG(lon_e) <= 20.0) {
     // Read W020N90
-    if (!BeamBlockageMapInternal_readTopographyHeader(self, "W020N90", &minfo)) {
-      goto done;
-    }
-    if ((field = BeamBlockageMapInternal_readData(self, "W020N90", &minfo)) == NULL) {
+    if ((field = BeamBlockageMapInternal_readTopography(self, "W020N90")) == NULL) {
       goto done;
     }
   } else if (RAD2DEG(lon_w) > 20.0) {
     // Read E020N90
-    if (!BeamBlockageMapInternal_readTopographyHeader(self, "E020N90", &minfo)) {
-      goto done;
-    }
-    if ((field = BeamBlockageMapInternal_readData(self, "E020N90", &minfo)) == NULL) {
+    if ((field = BeamBlockageMapInternal_readTopography(self, "E020N90")) == NULL) {
       goto done;
     }
   } else {
     // Read both
-    map_info minfo2;
-    map_info minfo3;
-    RaveField_t *field2 = NULL;
-    RaveField_t *field3 = NULL;
-
-    if (!BeamBlockageMapInternal_readTopographyHeader(self, "W020N90", &minfo2) ||
-        !BeamBlockageMapInternal_readTopographyHeader(self, "E020N90", &minfo3)) {
-      goto done;
-    }
-
-    field2 = BeamBlockageMapInternal_readData(self, "W020N90", &minfo2);
-    field3 = BeamBlockageMapInternal_readData(self, "E020N90", &minfo3);
-
+    BBTopography_t *field2 = BeamBlockageMapInternal_readTopography(self, "W020N90");
+    BBTopography_t *field3 = BeamBlockageMapInternal_readTopography(self, "E020N90");
     if (field2 != NULL && field3 != NULL) {
-      field = RaveField_concatX(field2, field3);
+      field = BBTopography_concatX(field2, field3);
     }
-
-    memcpy(&minfo, &minfo2, sizeof(map_info));
-    minfo.ncols += minfo3.ncols;
-
     RAVE_OBJECT_RELEASE(field2);
     RAVE_OBJECT_RELEASE(field3);
   }
-  /*
-  BYTEORDER      M
-  LAYOUT       BIL
-  NROWS         6000
-  NCOLS         4800
-  NBANDS        1
-  NBITS         16
-  BANDROWBYTES         9600
-  TOTALROWBYTES        9600
-  BANDGAPBYTES         0
-  NODATA        -9999
-  ULXMAP        -19.99583333333333
-  ULYMAP        89.99583333333334
-  XDIM          0.00833333333333
-  YDIM          0.00833333333333
-  */
-  if (field != NULL) {
-    // TODO: Add attributes to field
-  }
 
   result = RAVE_OBJECT_COPY(field);
 done:
index 4a25043..8527e61 100644 (file)
@@ -26,6 +26,7 @@ along with beamb.  If not, see <http://www.gnu.org/licenses/>.
 #define BEAMBLOCKAGEMAP_H
 #include "rave_object.h"
 #include "rave_field.h"
+#include "bbtopography.h"
 
 /**
  * Defines a beam blockage object
@@ -57,8 +58,8 @@ const char* BeamBlockageMap_getTopo30Directory(BeamBlockageMap_t* self);
  * @param[in] lat - latitude of radar in radians
  * @param[in] lon - longitude of radar in radians
  * @param[in] d - maximum range of radar in meters
- * @returns flag corresponding to map to be read
+ * @returns the topography field
  */
-RaveField_t* BeamBlockageMap_readTopography(BeamBlockageMap_t* self, double lat, double lon, double d);
+BBTopography_t* BeamBlockageMap_readTopography(BeamBlockageMap_t* self, double lat, double lon, double d);
 
 #endif /* BEAMBLOCKAGEMAP_H */
index 6587270..a05d911 100644 (file)
@@ -66,8 +66,8 @@ static PyObject *ErrorObject;
  * @param[in] beamb - the python beam blockage instance
  * @returns the native BeamBlockage_t instance.
  */
-static BBTopograhy_t*
-PyBBTopograhy_GetNative(PyBBTopograhy* topo)
+static BBTopography_t*
+PyBBTopography_GetNative(PyBBTopography* topo)
 {
   RAVE_ASSERT((topo != NULL), "topo == NULL");
   return RAVE_OBJECT_COPY(topo->topo);
@@ -79,13 +79,13 @@ PyBBTopograhy_GetNative(PyBBTopograhy* topo)
  * @param[in] p - the native object (or NULL)
  * @returns the python object.
  */
-static PyBBTopograhy* PyBBTopograhy_New(BBTopograhy_t* p)
+static PyBBTopography* PyBBTopography_New(BBTopography_t* p)
 {
-  PyBBTopograhy* result = NULL;
-  BBTopograhy_t* cp = NULL;
+  PyBBTopography* result = NULL;
+  BBTopography_t* cp = NULL;
 
   if (p == NULL) {
-    cp = RAVE_OBJECT_NEW(&BBTopograhy_TYPE);
+    cp = RAVE_OBJECT_NEW(&BBTopography_TYPE);
     if (cp == NULL) {
       RAVE_CRITICAL0("Failed to allocate memory for topography.");
       raiseException_returnNULL(PyExc_MemoryError, "Failed to allocate memory for topography.");
@@ -99,13 +99,13 @@ static PyBBTopograhy* PyBBTopograhy_New(BBTopograhy_t* p)
   }
 
   if (result == NULL) {
-    result = PyObject_NEW(PyBBTopograhy, &PyBBTopograhy_Type);
+    result = PyObject_NEW(PyBBTopography, &PyBBTopography_Type);
     if (result != NULL) {
       PYRAVE_DEBUG_OBJECT_CREATED;
       result->topo = RAVE_OBJECT_COPY(cp);
       RAVE_OBJECT_BIND(result->topo, result);
     } else {
-      RAVE_CRITICAL0("Failed to create PyBBTopograhy instance");
+      RAVE_CRITICAL0("Failed to create PyBBTopography instance");
       raiseException_gotoTag(done, PyExc_MemoryError, "Failed to allocate memory for topography.");
     }
   }
@@ -118,7 +118,7 @@ done:
  * Deallocates the object
  * @param[in] obj the object to deallocate.
  */
-static void _pybbtopography_dealloc(PyBBTopograhy* obj)
+static void _pybbtopography_dealloc(PyBBTopography* obj)
 {
   /*Nothing yet*/
   if (obj == NULL) {
@@ -141,10 +141,10 @@ static PyObject* _pybbtopography_new(PyObject* self, PyObject* args)
   if (!PyArg_ParseTuple(args, "")) {
     return NULL;
   }
-  return (PyObject*)PyBBTopograhy_New(NULL);
+  return (PyObject*)PyBBTopography_New(NULL);
 }
 
-static PyObject* _pybbtopography_getValue(PyBBTopograhy* self, PyObject* args)
+static PyObject* _pybbtopography_getValue(PyBBTopography* self, PyObject* args)
 {
   double value = 0.0L;
   long col = 0, row = 0;
@@ -159,7 +159,7 @@ static PyObject* _pybbtopography_getValue(PyBBTopograhy* self, PyObject* args)
   return Py_BuildValue("(id)", result, value);
 }
 
-static PyObject* _pybbtopography_setValue(PyBBTopograhy* self, PyObject* args)
+static PyObject* _pybbtopography_setValue(PyBBTopography* self, PyObject* args)
 {
   long col = 0, row = 0;
   double value = 0.0;
@@ -174,7 +174,7 @@ static PyObject* _pybbtopography_setValue(PyBBTopograhy* self, PyObject* args)
   Py_RETURN_NONE;
 }
 
-static PyObject* _pybbtopography_setData(PyBBTopograhy* self, PyObject* args)
+static PyObject* _pybbtopography_setData(PyBBTopography* self, PyObject* args)
 {
   PyObject* inarray = NULL;
   PyArrayObject* arraydata = NULL;
@@ -214,7 +214,7 @@ static PyObject* _pybbtopography_setData(PyBBTopograhy* self, PyObject* args)
   Py_RETURN_NONE;
 }
 
-static PyObject* _pybbtopography_getData(PyBBTopograhy* self, PyObject* args)
+static PyObject* _pybbtopography_getData(PyBBTopography* self, PyObject* args)
 {
   long ncols = 0, nrows = 0;
   RaveDataType type = RaveDataType_UNDEFINED;
@@ -251,6 +251,34 @@ static PyObject* _pybbtopography_getData(PyBBTopograhy* self, PyObject* args)
 }
 
 /**
+ * Concatenates two fields x-wise.
+ * @param[in] self - self
+ * @param[in] args - the other rave field object
+ * @return a topography object on success otherwise NULL
+ */
+static PyObject* _pybbtopography_concatx(PyBBTopography* self, PyObject* args)
+{
+  PyObject* result = NULL;
+  PyObject* pyin = NULL;
+  BBTopography_t *field = NULL;
+  if (!PyArg_ParseTuple(args, "O", &pyin)) {
+    return NULL;
+  }
+  if (!PyBBTopography_Check(pyin)) {
+    raiseException_returnNULL(PyExc_ValueError, "Argument must be another topography field");
+  }
+  field = BBTopography_concatX(self->topo, ((PyBBTopography*)pyin)->topo);
+  if (field == NULL) {
+    raiseException_gotoTag(done, PyExc_ValueError, "Failed to concatenate fields");
+  }
+
+  result = (PyObject*)PyBBTopography_New(field);
+done:
+  RAVE_OBJECT_RELEASE(field);
+  return result;
+}
+
+/**
  * All methods a topography instance can have
  */
 static struct PyMethodDef _pybbtopography_methods[] =
@@ -266,13 +294,14 @@ static struct PyMethodDef _pybbtopography_methods[] =
   {"setValue", (PyCFunction)_pybbtopography_setValue, 1},
   {"setData", (PyCFunction)_pybbtopography_setData, 1},
   {"getData", (PyCFunction)_pybbtopography_getData, 1},
+  {"concatx", (PyCFunction)_pybbtopography_concatx, 1},
   {NULL, NULL} /* sentinel */
 };
 
 /**
  * Returns the specified attribute in the beam blockage
  */
-static PyObject* _pybbtopography_getattr(PyBBTopograhy* self, char* name)
+static PyObject* _pybbtopography_getattr(PyBBTopography* self, char* name)
 {
   PyObject* res = NULL;
   if (strcmp("nodata", name) == 0) {
@@ -303,7 +332,7 @@ static PyObject* _pybbtopography_getattr(PyBBTopograhy* self, char* name)
 /**
  * Returns the specified attribute in the polar volume
  */
-static int _pybbtopography_setattr(PyBBTopograhy* self, char* name, PyObject* val)
+static int _pybbtopography_setattr(PyBBTopography* self, char* name, PyObject* val)
 {
   int result = -1;
   if (name == NULL) {
@@ -365,11 +394,11 @@ done:
 /// Type definitions
 /// --------------------------------------------------------------------
 /*@{ Type definitions */
-PyTypeObject PyBBTopograhy_Type =
+PyTypeObject PyBBTopography_Type =
 {
   PyObject_HEAD_INIT(NULL)0, /*ob_size*/
   "BBTopographyCore", /*tp_name*/
-  sizeof(PyBBTopograhy), /*tp_size*/
+  sizeof(PyBBTopography), /*tp_size*/
   0, /*tp_itemsize*/
   /* methods */
   (destructor)_pybbtopography_dealloc, /*tp_dealloc*/
@@ -399,19 +428,19 @@ PyMODINIT_FUNC
 init_bbtopography(void)
 {
   PyObject *module=NULL,*dictionary=NULL;
-  static void *PyBBTopograhy_API[PyBBTopograhy_API_pointers];
+  static void *PyBBTopography_API[PyBBTopography_API_pointers];
   PyObject *c_api_object = NULL;
-  PyBBTopograhy_Type.ob_type = &PyType_Type;
+  PyBBTopography_Type.ob_type = &PyType_Type;
 
   module = Py_InitModule("_bbtopography", functions);
   if (module == NULL) {
     return;
   }
-  PyBBTopograhy_API[PyBBTopograhy_Type_NUM] = (void*)&PyBBTopograhy_Type;
-  PyBBTopograhy_API[PyBBTopograhy_GetNative_NUM] = (void *)PyBBTopograhy_GetNative;
-  PyBBTopograhy_API[PyBBTopograhy_New_NUM] = (void*)PyBBTopograhy_New;
+  PyBBTopography_API[PyBBTopography_Type_NUM] = (void*)&PyBBTopography_Type;
+  PyBBTopography_API[PyBBTopography_GetNative_NUM] = (void *)PyBBTopography_GetNative;
+  PyBBTopography_API[PyBBTopography_New_NUM] = (void*)PyBBTopography_New;
 
-  c_api_object = PyCObject_FromVoidPtr((void *)PyBBTopograhy_API, NULL);
+  c_api_object = PyCObject_FromVoidPtr((void *)PyBBTopography_API, NULL);
 
   if (c_api_object != NULL) {
     PyModule_AddObject(module, "_C_API", c_api_object);
index 6af98bc..afb7fae 100644 (file)
@@ -32,63 +32,63 @@ along with beamb.  If not, see <http://www.gnu.org/licenses/>.
  */
 typedef struct {
    PyObject_HEAD /*Always have to be on top*/
-   BBTopograhy_t* topo;  /**< the native object */
-} PyBBTopograhy;
+   BBTopography_t* topo;  /**< the native object */
+} PyBBTopography;
 
-#define PyBBTopograhy_Type_NUM 0                              /**< index of type */
+#define PyBBTopography_Type_NUM 0                              /**< index of type */
 
-#define PyBBTopograhy_GetNative_NUM 1                         /**< index of GetNative*/
-#define PyBBTopograhy_GetNative_RETURN BBTopograhy_t*         /**< return type for GetNative */
-#define PyBBTopograhy_GetNative_PROTO (PyBBTopograhy*)        /**< arguments for GetNative */
+#define PyBBTopography_GetNative_NUM 1                         /**< index of GetNative*/
+#define PyBBTopography_GetNative_RETURN BBTopography_t*         /**< return type for GetNative */
+#define PyBBTopography_GetNative_PROTO (PyBBTopography*)        /**< arguments for GetNative */
 
-#define PyBBTopograhy_New_NUM 2                               /**< index of New */
-#define PyBBTopograhy_New_RETURN PyBBTopograhy*              /**< return type for New */
-#define PyBBTopograhy_New_PROTO (BBTopograhy_t*)             /**< arguments for New */
+#define PyBBTopography_New_NUM 2                               /**< index of New */
+#define PyBBTopography_New_RETURN PyBBTopography*              /**< return type for New */
+#define PyBBTopography_New_PROTO (BBTopography_t*)             /**< arguments for New */
 
-#define PyBBTopograhy_API_pointers 3                          /**< number of type and function pointers */
+#define PyBBTopography_API_pointers 3                          /**< number of type and function pointers */
 
 #ifdef PYBBTOPOGRAPHY_MODULE
 /** Forward declaration of type */
-extern PyTypeObject PyBBTopograhy_Type;
+extern PyTypeObject PyBBTopography_Type;
 
-/** Checks if the object is a PyBBTopograhy or not */
-#define PyBBTopograhy_Check(op) ((op)->ob_type == &PyBBTopograhy_Type)
+/** Checks if the object is a PyBBTopography or not */
+#define PyBBTopography_Check(op) ((op)->ob_type == &PyBBTopography_Type)
 
-/** Forward declaration of PyBBTopograhy_GetNative */
-static PyBBTopograhy_GetNative_RETURN PyBBTopograhy_GetNative PyBBTopograhy_GetNative_PROTO;
+/** Forward declaration of PyBBTopography_GetNative */
+static PyBBTopography_GetNative_RETURN PyBBTopography_GetNative PyBBTopography_GetNative_PROTO;
 
 /** Forward declaration of PyRopoGenerator_New */
-static PyBBTopograhy_New_RETURN PyBBTopograhy_New PyBBTopograhy_New_PROTO;
+static PyBBTopography_New_RETURN PyBBTopography_New PyBBTopography_New_PROTO;
 
 #else
 /** Pointers to types and functions */
-static void **PyBBTopograhy_API;
+static void **PyBBTopography_API;
 
 /**
  * Returns a pointer to the internal object, remember to release the reference
  * when done with the object. (RAVE_OBJECT_RELEASE).
  */
-#define PyBBTopograhy_GetNative \
-  (*(PyBBTopograhy_GetNative_RETURN (*)PyBBTopograhy_GetNative_PROTO) PyBBTopograhy_API[PyBBTopograhy_GetNative_NUM])
+#define PyBBTopography_GetNative \
+  (*(PyBBTopography_GetNative_RETURN (*)PyBBTopography_GetNative_PROTO) PyBBTopography_API[PyBBTopography_GetNative_NUM])
 
 /**
- * Creates a new instance. Release this object with Py_DECREF. If a BBTopograhy_t instance is
+ * Creates a new instance. Release this object with Py_DECREF. If a BBTopography_t instance is
  * provided and this instance already is bound to a python instance, this instance will be increfed and
  * returned.
- * @param[in] obj - the BBTopograhy_t instance.
- * @returns the PyBBTopograhy instance.
+ * @param[in] obj - the BBTopography_t instance.
+ * @returns the PyBBTopography instance.
  */
-#define PyBBTopograhy_New \
-  (*(PyBBTopograhy_New_RETURN (*)PyBBTopograhy_New_PROTO) PyBBTopograhy_API[PyBBTopograhy_New_NUM])
+#define PyBBTopography_New \
+  (*(PyBBTopography_New_RETURN (*)PyBBTopography_New_PROTO) PyBBTopography_API[PyBBTopography_New_NUM])
 
 /**
  * Checks if the object is a python topography instance
  */
-#define PyBBTopograhy_Check(op) \
-   ((op)->ob_type == (PyTypeObject *)PyBBTopograhy_API[PyBBTopograhy_Type_NUM])
+#define PyBBTopography_Check(op) \
+   ((op)->ob_type == (PyTypeObject *)PyBBTopography_API[PyBBTopography_Type_NUM])
 
 /**
- * Imports the PyBBTopograhy module (like import _bbtopography in python).
+ * Imports the PyBBTopography module (like import _bbtopography in python).
  */
 static int
 import_bbtopography(void)
@@ -107,7 +107,7 @@ import_bbtopography(void)
     return -1;
   }
   if (PyCObject_Check(c_api_object)) {
-    PyBBTopograhy_API = (void **)PyCObject_AsVoidPtr(c_api_object);
+    PyBBTopography_API = (void **)PyCObject_AsVoidPtr(c_api_object);
   }
   Py_DECREF(c_api_object);
   Py_DECREF(module);
index 92cf1a0..2420ce2 100644 (file)
@@ -32,7 +32,7 @@ along with beamb.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "pyrave_debug.h"
 #include "rave_alloc.h"
-#include "pyravefield.h"
+#include "pybbtopography.h"
 
 /**
  * Debug this module
@@ -155,14 +155,14 @@ static PyObject* _pybeamblockagemap_readTopography(PyBeamBlockageMap* self, PyOb
 {
   double lat = 0.0, lon = 0.0, radius = 0.0;
   PyObject* result = NULL;
-  RaveField_t* field = NULL;
+  BBTopography_t* field = NULL;
 
   if (!PyArg_ParseTuple(args, "ddd", &lat, &lon, &radius)) {
     return NULL;
   }
   field = BeamBlockageMap_readTopography(self->map, lat, lon, radius);
   if (field != NULL) {
-    result = (PyObject*)PyRaveField_New(field);
+    result = (PyObject*)PyBBTopography_New(field);
   } else {
     PyErr_SetString(PyExc_EnvironmentError, "Could not open topography");
   }
@@ -298,7 +298,7 @@ init_beamblockagemap(void)
   if (ErrorObject == NULL || PyDict_SetItemString(dictionary, "error", ErrorObject) != 0) {
     Py_FatalError("Can't define _beamblockagemap.error");
   }
-  import_pyravefield();
+  import_bbtopography();
   PYRAVE_DEBUG_INITIALIZE;
 }
 /*@} End of Module setup */
index c514814..f75e1e4 100644 (file)
@@ -38,41 +38,41 @@ class PyBBTopographyTest(unittest.TestCase):
   def tearDown(self):
     pass
   
-  def testNew(self):
+  def test_new(self):
     a = _bbtopography.new()
     self.assertNotEqual(-1, string.find(`type(a)`, "BBTopographyCore"))
 
-  def testNodata(self):
+  def test_nodata(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(-9999.0, a.nodata, 4)
     a.nodata = 10.0
     self.assertAlmostEqual(10.0, a.nodata, 4)
 
-  def testUlxmap(self):
+  def test_ulxmap(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.ulxmap, 4)
     a.ulxmap = 2.5
     self.assertAlmostEqual(2.5, a.ulxmap, 4)
 
-  def testUyxmap(self):
+  def test_ulymap(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.ulymap, 4)
     a.ulymap = 2.5
     self.assertAlmostEqual(2.5, a.ulymap, 4)
 
-  def testXdim(self):
+  def test_xdim(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.xdim, 4)
     a.xdim = 2.5
     self.assertAlmostEqual(2.5, a.xdim, 4)
 
-  def testYdim(self):
+  def test_ydim(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.ydim, 4)
     a.ydim = 2.5
     self.assertAlmostEqual(2.5, a.ydim, 4)
     
-  def testNcols(self):
+  def test_ncols(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.ncols, 4)
     try:
@@ -82,7 +82,7 @@ class PyBBTopographyTest(unittest.TestCase):
       pass
     self.assertAlmostEqual(0.0, a.ncols, 4)
 
-  def testNrows(self):
+  def test_nrows(self):
     a = _bbtopography.new()
     self.assertAlmostEqual(0.0, a.nrows, 4)
     try:
@@ -92,7 +92,7 @@ class PyBBTopographyTest(unittest.TestCase):
       pass
     self.assertAlmostEqual(0.0, a.nrows, 4)
 
-  def testData(self):
+  def test_data(self):
     obj = _bbtopography.new()
     obj.setData(numpy.zeros((10,10), numpy.uint8))
     obj.setValue(0,1,10.0)
@@ -102,6 +102,25 @@ class PyBBTopographyTest(unittest.TestCase):
     self.assertEqual(10, data[1][0])
     self.assertEqual(20, data[4][5])
 
+  def test_concatx(self):
+    obj = _bbtopography.new()
+    obj.setData(numpy.zeros((10,10), numpy.uint8))
+    obj.setValue(0,1,10.0)
+    obj.setValue(5,4,20.0)
+
+    obj2 = _bbtopography.new()
+    obj2.setData(numpy.zeros((10,6), numpy.uint8))
+    obj2.setValue(0,1,15.0)
+    obj2.setValue(5,4,25.0)
+
+    result = obj.concatx(obj2)
+    self.assertEquals(16, result.ncols)
+    self.assertEquals(10, result.nrows)
+    self.assertAlmostEquals(10.0, result.getValue(0,1)[1], 4)
+    self.assertAlmostEquals(20.0, result.getValue(5,4)[1], 4)
+    self.assertAlmostEquals(15.0, result.getValue(10,1)[1], 4)
+    self.assertAlmostEquals(25.0, result.getValue(15,4)[1], 4)    
+
 if __name__ == "__main__":
   #import sys;sys.argv = ['', 'Test.testName']
   unittest.main()
\ No newline at end of file
index b347f24..34ff32c 100644 (file)
@@ -54,16 +54,16 @@ class PyBeamBlockageMapTest(unittest.TestCase):
     a.topo30dir="../../data/gtopo30"
     result = a.readTopography(60*math.pi/180, 14*math.pi/180.0, 100000)
     self.assertTrue(result != None)
-    self.assertEquals(6000, result.ysize)
-    self.assertEquals(4800, result.xsize)
+    self.assertEquals(6000, result.nrows)
+    self.assertEquals(4800, result.ncols)
     
   def testReadTopo30_combined(self):
     a = _beamblockagemap.new()
     a.topo30dir="../../data/gtopo30"
     result = a.readTopography(60*math.pi/180, 20*math.pi/180.0, 200000)
     self.assertTrue(result != None)
-    self.assertEquals(6000, result.ysize)
-    self.assertEquals(9600, result.xsize)
+    self.assertEquals(6000, result.nrows)
+    self.assertEquals(9600, result.ncols)
   
 if __name__ == "__main__":
   #import sys;sys.argv = ['', 'Test.testName']