[GRASS-SVN] r57752 - sandbox/turek/scatter_plot
svn_grass at osgeo.org
svn_grass at osgeo.org
Thu Sep 19 14:06:28 PDT 2013
Author: turek
Date: 2013-09-19 14:06:27 -0700 (Thu, 19 Sep 2013)
New Revision: 57752
Modified:
sandbox/turek/scatter_plot/testing_patch.diff
Log:
scatter plot:various improvemnts
Modified: sandbox/turek/scatter_plot/testing_patch.diff
===================================================================
--- sandbox/turek/scatter_plot/testing_patch.diff 2013-09-19 12:53:28 UTC (rev 57751)
+++ sandbox/turek/scatter_plot/testing_patch.diff 2013-09-19 21:06:27 UTC (rev 57752)
@@ -1,6 +1,1305 @@
+Index: lib/imagery/scatt_sccats.c
+===================================================================
+--- lib/imagery/scatt_sccats.c (revision 0)
++++ lib/imagery/scatt_sccats.c (working copy)
+@@ -0,0 +1,405 @@
++/*!
++ \file lib/imagery/scatt_cat_rast.c
++
++ \brief Imagery library - functions for manipulation with scatter plot structs.
++
++ Copyright (C) 2013 by the GRASS Development Team
++
++ This program is free software under the GNU General Public License
++ (>=v2). Read the file COPYING that comes with GRASS for details.
++
++ \author Stepan Turek <stepan.turek at seznam.cz> (Mentor: Martin Landa)
++ */
++
++#include <grass/raster.h>
++#include <grass/imagery.h>
++#include <grass/gis.h>
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <math.h>
++#include <string.h>
++
++/*!
++ \brief Compute band ids from scatter plot id.
++
++ Scatter plot id describes which bands defines the scatter plot.
++
++ Let say we have 3 bands, their ids are 0, 1 and 2.
++ Scatter plot with id 0 consists of band 1 (b_1_id) 0 and band 2 (b_2_id) 1.
++ All scatter plots:
++ scatt_id b_1_id b_2_id
++ 0 0 1
++ 1 0 2
++ 2 1 2
++
++ \param scatt_id scatter plot id
++ \param n_bands number of bands
++ \param [out] b_1_id id of band1
++ \param[out] b_2_id id of band2
++
++ \return 0
++ */
++int I_id_scatt_to_bands(const int scatt_id, const int n_bands, int * b_1_id, int * b_2_id)
++{
++ int n_b1 = n_bands - 1;
++
++ * b_1_id = (int) ((2 * n_b1 + 1 - sqrt((double)((2 * n_b1 + 1) * (2 * n_b1 + 1) - 8 * scatt_id))) / 2);
++
++ * b_2_id = scatt_id - ((* b_1_id) * (2 * n_b1 + 1) - (* b_1_id) * (* b_1_id)) / 2 + (* b_1_id) + 1;
++
++ return 0;
++}
++
++
++/*!
++ \brief Compute scatter plot id from band ids.
++
++ See also I_id_scatt_to_bands().
++
++ \param n_bands number of bands
++ \param b_1_id id of band1
++ \param b_1_id id of band2
++ \param [out] scatt_id scatter plot id
++
++ \return 0
++ */
++int I_bands_to_id_scatt(const int b_1_id, const int b_2_id, const int n_bands, int * scatt_id)
++{
++ int n_b1 = n_bands - 1;
++
++ * scatt_id = (b_1_id * (2 * n_b1 + 1) - b_1_id * b_1_id) / 2 + b_2_id - b_1_id - 1;
++
++ return 0;
++}
++
++/*!
++ \brief Initialize structure for storing scatter plots data.
++
++ \param cats pointer to scCats struct
++ \param n_bands number of bands
++ \param type SC_SCATT_DATA - stores scatter plots
++ \param type SC_SCATT_CONDITIONS - stores selected areas in scatter plots
++ */
++void I_sc_init_cats(struct scCats * cats, int n_bands, int type)
++{
++ int i_cat;
++
++ cats->type = type;
++
++ cats->n_cats = 100;
++ cats->n_a_cats = 0;
++
++ cats->n_bands = n_bands;
++ cats->n_scatts = (n_bands - 1) * n_bands / 2;
++
++ cats->cats_arr = (struct scScatts **) G_malloc(cats->n_cats * sizeof(struct scScatts *));
++ memset(cats->cats_arr, 0, cats-> n_cats * sizeof(struct scScatts *));
++
++ cats->cats_ids = (int *) G_malloc(cats->n_cats * sizeof(int));
++ cats->cats_idxs =(int *) G_malloc(cats->n_cats * sizeof(int));
++
++ for(i_cat = 0; i_cat < cats->n_cats; i_cat++)
++ cats->cats_idxs[i_cat] = -1;
++
++ return;
++}
++
++/*!
++ \brief Free data of struct scCats, the structure itself remains alocated.
++
++ \param cats pointer to existing scCats struct
++ */
++void I_sc_free_cats(struct scCats * cats)
++{
++ int i_cat;
++
++ for(i_cat = 0; i_cat < cats->n_a_cats; i_cat++)
++ {
++ if(cats->cats_arr[i_cat])
++ {
++ G_free(cats->cats_arr[i_cat]->scatt_idxs);
++ G_free(cats->cats_arr[i_cat]->scatts_bands);
++ G_free(cats->cats_arr[i_cat]->scatts_arr);
++ G_free(cats->cats_arr[i_cat]);
++ }
++ }
++
++ G_free(cats->cats_ids);
++ G_free(cats->cats_idxs);
++ G_free(cats->cats_arr);
++
++ cats->n_cats = 0;
++ cats->n_a_cats = 0;
++ cats->n_bands = 0;
++ cats->n_scatts = 0;
++ cats->type = -1;
++
++ return;
++}
++
++#if 0
++void I_sc_get_active_categories(int * a_cats_ids, int * n_a_cats, struct scCats * cats)
++{
++ a_cats_ids = cats->cats_ids;
++ * n_a_cats = cats->n_a_cats;
++}
++#endif
++
++/*!
++ \brief Add category.
++
++ Category represents group of scatter plots.
++
++ \param cats pointer to scCats struct
++
++ \return assigned category id (starts with 0)
++ \return -1 if maximum nuber of categories was reached
++ */
++int I_sc_add_cat(struct scCats * cats)
++{
++ int i_scatt, i_cat_id, cat_id;
++ int n_a_cats = cats->n_a_cats;
++
++ if(cats->n_a_cats >= cats->n_cats)
++ return -1;
++
++ for(i_cat_id = 0; i_cat_id < cats->n_cats; i_cat_id++)
++ if(cats->cats_idxs[i_cat_id] < 0) {
++ cat_id = i_cat_id;
++ break;
++ }
++
++ cats->cats_ids[n_a_cats] = cat_id;
++ cats->cats_idxs[cat_id] = n_a_cats;
++
++ cats->cats_arr[n_a_cats] = (struct scScatts *) G_malloc(sizeof(struct scScatts));
++
++ cats->cats_arr[n_a_cats]->scatts_arr = (struct scdScattData **) G_malloc(cats->n_scatts * sizeof(struct scdScattData *));
++ memset((cats->cats_arr[n_a_cats]->scatts_arr), 0, cats->n_scatts * sizeof(struct scdScattData *));
++
++ cats->cats_arr[n_a_cats]->n_a_scatts = 0;
++
++ cats->cats_arr[n_a_cats]->scatts_bands = (int *) G_malloc(cats->n_scatts * 2 * sizeof(int));
++
++ cats->cats_arr[n_a_cats]->scatt_idxs = (int *) G_malloc(cats->n_scatts * sizeof(int));
++ for(i_scatt = 0; i_scatt < cats->n_scatts; i_scatt++)
++ cats->cats_arr[n_a_cats]->scatt_idxs[i_scatt] = -1;
++
++ ++cats->n_a_cats;
++
++ return cat_id;
++}
++
++#if 0
++int I_sc_delete_cat(struct scCats * cats, int cat_id)
++{
++ int cat_idx, i_cat;
++
++ if(cat_id < 0 || cat_id >= cats->n_cats)
++ return -1;
++
++ cat_idx = cats->cats_idxs[cat_id];
++ if(cat_idx < 0)
++ return -1;
++
++ G_free(cats->cats_arr[cat_idx]->scatt_idxs);
++ G_free(cats->cats_arr[cat_idx]->scatts_bands);
++ G_free(cats->cats_arr[cat_idx]->scatts_arr);
++ G_free(cats->cats_arr[cat_idx]);
++
++ for(i_cat = cat_idx; i_cat < cats->n_a_cats - 1; i_cat++)
++ {
++ cats->cats_arr[i_cat] = cats->cats_arr[i_cat + 1];
++ cats->cats_ids[i_cat] = cats->cats_ids[i_cat + 1];
++ }
++ cats->cats_idxs[cat_id] = -1;
++
++ --cats->n_a_cats;
++
++ return 0;
++}
++#endif
++
++/*!
++ \brief Insert scatter plot data .
++ Inserted scatt_data struct must have same type as cats struct (SC_SCATT_DATA or SC_SCATT_CONDITIONS).
++
++ \param cats pointer to scCats struct
++ \param cat_id id number of category.
++ \param scatt_id id number of scatter plot.
++
++ \return 0 on success
++ \return -1 on failure
++ */
++int I_sc_insert_scatt_data(struct scCats * cats, struct scdScattData * scatt_data, int cat_id, int scatt_id)
++{
++ int band_1, band_2, cat_idx, n_a_scatts;
++ struct scScatts * scatts;
++
++ if(cat_id < 0 || cat_id >= cats->n_cats)
++ return -1;
++
++ cat_idx = cats->cats_idxs[cat_id];
++ if(cat_idx < 0)
++ return -1;
++
++ if(scatt_id < 0 && scatt_id >= cats->n_scatts)
++ return -1;
++
++ scatts = cats->cats_arr[cat_idx];
++ if(scatts->scatt_idxs[scatt_id] >= 0)
++ return -1;
++
++ if(!scatt_data->b_conds_arr && cats->type == SC_SCATT_CONDITIONS)
++ return -1;
++
++ if(!scatt_data->scatt_vals_arr && cats->type == SC_SCATT_DATA)
++ return -1;
++
++ n_a_scatts = scatts->n_a_scatts;
++
++ scatts->scatt_idxs[scatt_id] = n_a_scatts;
++
++ I_id_scatt_to_bands(scatt_id, cats->n_bands, &band_1, &band_2);
++
++ scatts->scatts_bands[n_a_scatts * 2] = band_1;
++ scatts->scatts_bands[n_a_scatts * 2 + 1] = band_2;
++
++ scatts->scatts_arr[n_a_scatts] = scatt_data;
++ ++scatts->n_a_scatts;
++
++ return 0;
++}
++
++#if 0
++int I_sc_remove_scatt_data(struct scCats * cats, struct scdScattData * scatt_data, int cat_id, int scatt_id)
++{
++ int cat_idx, scatt_idx, n_init_scatts, i_scatt;
++ struct scScatts * scatts;
++
++ if(cat_id < 0 && cat_id >= cats->n_cats)
++ return -1;
++
++ cat_idx = cats->cats_idxs[cat_id];
++ if(cat_idx < 0)
++ return -1;
++
++ if(scatt_id < 0 || scatt_id >= cats->n_scatts)
++ return -1;
++
++ scatts = cats->cats_arr[cat_idx];
++ if(scatts->scatt_idxs[scatt_id] < 0)
++ return -1;
++
++ scatt_data = scatts->scatts_arr[scatt_idx];
++
++ for(i_scatt = scatt_idx; i_scatt < scatts->n_a_scatts - 1; i_scatt++)
++ {
++ scatts->scatts_arr[i_scatt] = scatts->scatts_arr[i_scatt + 1];
++ scatts->scatts_bands[i_scatt * 2] = scatts->scatts_bands[(i_scatt + 1)* 2];
++ scatts->scatts_bands[i_scatt * 2 + 1] = scatts->scatts_bands[(i_scatt + 1) * 2 + 1];
++ }
++ scatts->scatts_arr[scatts->n_a_scatts] = NULL;
++
++ scatts->scatt_idxs[scatt_id] = -1;
++
++ scatt_data = scatts->scatts_arr[scatt_id];
++ scatts->n_a_scatts--;
++
++ return 0;
++}
++
++int I_sc_set_value(struct scCats * cats, int cat_id, int scatt_id, int value_idx, int value)
++{
++ int n_a_scatts = cats->cats_arr[cat_id]->n_a_scatts;
++ int cat_idx, scatt_idx, ret;
++
++ cat_idx = cats->cats_idxs[cat_id];
++ if(cat_idx < 0)
++ return -1;
++
++ if(cats->cats_arr[cat_idx]->scatt_idxs[scatt_id] < 0)
++ return -1;
++
++ cat_idx = cats->cats_idxs[cat_id];
++ scatt_idx = cats->cats_arr[cat_idx]->scatt_idxs[scatt_id];
++
++ I_scd_set_value(cats->cats_arr[cat_idx]->scatts_arr[scatt_idx], value_idx, value);
++
++ return 0;
++}
++#endif
++
++/*!
++ \brief Insert scatter plot data.
++
++ \param scatt_data pointer to existing struct scdScattData
++ \param type SC_SCATT_DATA for scatter plots or SC_SCATT_CONDITIONS for selected areas in scatter plot
++ \param n_vals number of data values
++ \param data array of values (unsigned char for SC_SCATT_CONDITIONS, unsigned int for SC_SCATT_DATA)
++ */
++void I_scd_init_scatt_data(struct scdScattData * scatt_data, int type, int n_vals, void * data)
++{
++ scatt_data->n_vals = n_vals;
++
++ if(type == SC_SCATT_DATA)
++ {
++ if(data)
++ scatt_data->scatt_vals_arr = (unsigned int *) data;
++ else {
++ scatt_data->scatt_vals_arr = (unsigned int *) G_malloc(n_vals * sizeof(unsigned int));
++ memset(scatt_data->scatt_vals_arr, 0, n_vals * sizeof(unsigned int));
++ }
++ scatt_data->b_conds_arr = NULL;
++ }
++ else if(type == SC_SCATT_CONDITIONS)
++ {
++ if(data)
++ scatt_data->b_conds_arr = (unsigned char *) data;
++ else {
++ scatt_data->b_conds_arr = (unsigned char *) G_malloc(n_vals * sizeof(unsigned char));
++ memset(scatt_data->b_conds_arr, 0, n_vals * sizeof(unsigned char));
++ }
++ scatt_data->scatt_vals_arr = NULL;
++ }
++
++ return;
++}
++
++
++#if 0
++void I_scd_get_range_min_max(struct scdScattData * scatt_data, CELL * band_1_min, CELL * band_1_max, CELL * band_2_min, CELL * band_2_max)
++{
++
++ Rast_get_range_min_max(&(scatt_data->band_1_range), band_1_min, band_2_min);
++ Rast_get_range_min_max(&(scatt_data->band_2_range), band_2_min, band_2_max);
++
++ return;
++}
++s
++void * I_scd_get_data_ptr(struct scdScattData * scatt_data)
++{
++ if(!scatt_data->b_conds_arr)
++ return scatt_data->b_conds_arr;
++ else if(!scatt_data->scatt_vals_arr)
++ return scatt_data->scatt_vals_arr;
++
++ return NULL;
++}
++
++int I_scd_set_value(struct scdScattData * scatt_data, unsigned int val_idx, unsigned int val)
++{
++ if(val_idx < 0 && val_idx > scatt_data->n_vals)
++ return -1;
++
++ if(scatt_data->b_conds_arr)
++ scatt_data->b_conds_arr[val_idx] = val;
++ else if(scatt_data->scatt_vals_arr)
++ scatt_data->scatt_vals_arr[val_idx] = val;
++ else
++ return -1;
++
++ return 0;
++}
++#endif
+Index: lib/imagery/scatt.c
+===================================================================
+--- lib/imagery/scatt.c (revision 0)
++++ lib/imagery/scatt.c (working copy)
+@@ -0,0 +1,871 @@
++/*!
++ \file lib/imagery/scatt.c
++
++ \brief Imagery library - functions for wx Scatter Plot Tool.
++
++ Low level functions used by wx Scatter Plot Tool.
++
++ Copyright (C) 2013 by the GRASS Development Team
++
++ This program is free software under the GNU General Public License
++ (>=v2). Read the file COPYING that comes with GRASS for details.
++
++ \author Stepan Turek <stepan.turek at seznam.cz> (Mentor: Martin Landa)
++ */
++#include <stdio.h>
++#include <stdlib.h>
++#include <math.h>
++#include <string.h>
++
++#include <grass/gis.h>
++#include <grass/vector.h>
++#include <grass/raster.h>
++#include <grass/imagery.h>
++#include <grass/glocale.h>
++
++#include "iclass_local_proto.h"
++
++struct rast_row
++{
++ CELL * row;
++ char * null_row;
++ struct Range rast_range; /*Range of whole raster.*/
++};
++
++/*!
++ \brief Create pgm header.
++
++ Scatter plot internally generates pgm files. These pgms have header in format created by this function.
++
++ \param region region to be pgm header generated for
++ \param [out] header header of pgm file
++ */
++static int get_cat_rast_header(struct Cell_head * region, char * header){
++ return sprintf(header, "P5\n%d\n%d\n1\n", region->cols, region->rows);
++}
++
++/*!
++ \brief Create category raster conditions file.
++
++ \param cat_rast_region region to be file generated for
++ \param cat_rast path of generated category raster file
++ */
++int I_create_cat_rast(struct Cell_head * cat_rast_region, const char * cat_rast)
++{
++ FILE * f_cat_rast;
++ char cat_rast_header[1024];//TODO magic number
++ int i_row, i_col;
++ int head_nchars;
++
++ unsigned char * row_data;
++
++ f_cat_rast = fopen(cat_rast, "wb");
++ if(!f_cat_rast) {
++ G_warning("Unable to create category raster condition file <%s>.", cat_rast);
++ return -1;
++ }
++
++ head_nchars = get_cat_rast_header(cat_rast_region, cat_rast_header);
++
++ fwrite(cat_rast_header, sizeof(char), head_nchars/sizeof(char), f_cat_rast);
++ if (ferror(f_cat_rast)){
++ fclose(f_cat_rast);
++ G_warning(_("Unable to write header into category raster condition file <%s>."), cat_rast);
++ return -1;
++ }
++
++ row_data = (unsigned char *) G_malloc(cat_rast_region->cols * sizeof(unsigned char));
++ for(i_col = 0; i_col < cat_rast_region->cols; i_col++)
++ row_data[i_col] = 0 & 255;
++
++ for(i_row = 0; i_row < cat_rast_region->rows; i_row++) {
++ fwrite(row_data, sizeof(unsigned char), (cat_rast_region->cols)/sizeof(unsigned char), f_cat_rast);
++ if (ferror(f_cat_rast))
++ {
++ fclose(f_cat_rast);
++ G_warning(_("Unable to write into category raster condition file <%s>."), cat_rast);
++ return -1;
++ }
++ }
++
++ fclose(f_cat_rast);
++ return 0;
++}
++
++static int print_reg(struct Cell_head * intersec, const char * pref, int dbg_level)
++{
++ G_debug(dbg_level, "%s:\n n:%f\ns:%f\ne:%f\nw:%f\nns_res:%f\new_res:%f", pref, intersec->north, intersec->south,
++ intersec->east, intersec->west, intersec->ns_res, intersec->ew_res);
++}
++
++/*!
++ \brief Find intersection region of two regions.
++
++ \param A pointer to intersected region
++ \param B pointer to intersected region
++ \param [out] intersec pointer to intersection region of regions A B (relevant params of the region are: south, north, east, west)
++
++ \return 0 if interection exists
++ \return -1 if regions does not intersect
++ */
++static int regions_intersecion(struct Cell_head * A, struct Cell_head * B, struct Cell_head * intersec)
++{
++
++ if(B->north < A->south) return -1;
++ else if(B->north > A->north) intersec->north = A->north;
++ else intersec->north = B->north;
++
++ if(B->south > A->north) return -1;
++ else if(B->south < A->south) intersec->south = A->south;
++ else intersec->south = B->south;
++
++ if(B->east < A->west) return -1;
++ else if(B->east > A->east) intersec->east = A->east;
++ else intersec->east = B->east;
++
++ if(B->west > A->east) return -1;
++ else if(B->west < A->west) intersec->west = A->west;
++ else intersec->west = B->west;
++
++ if(intersec->north == intersec->south) return -1;
++
++ if(intersec->east == intersec->west) return -1;
++
++ return 0;
++
++}
++
++/*!
++ \brief Get rows and cols numbers, which defines intersection of the regions.
++
++ \param A pointer to intersected region
++ \param B pointer to intersected region (A and B must have same resolution)
++ \param [out] A_bounds rows and cols numbers of A stored in south, north, east, west, which defines intersection of A and B
++ \param [out] B_bounds rows and cols numbers of B stored in south, north, east, west, which defines intersection of A and B
++
++ \return 0 if interection exists
++ \return -1 if regions do not intersect
++ \return -2 resolution of regions is not same
++*/
++static int get_rows_and_cols_bounds(struct Cell_head * A, struct Cell_head * B, struct Cell_head * A_bounds, struct Cell_head * B_bounds)
++{
++ float ns_res, ew_res;
++
++ struct Cell_head intersec;
++
++ /* TODO is it right check? */
++ if(abs(A->ns_res - B->ns_res) > GRASS_EPSILON) {
++ G_debug(0, "'get_rows_and_cols_bounds' ns_res does not fit, A->ns_res: %f B->ns_res: %f", A->ns_res, B->ns_res);
++ return -2;
++ }
++
++ if(abs(A->ew_res - B->ew_res) > GRASS_EPSILON) {
++ G_debug(0, "'get_rows_and_cols_bounds' ew_res does not fit, A->ew_res: %f B->ew_res: %f", A->ew_res, B->ew_res);
++ return -2;
++ }
++
++ ns_res = A->ns_res;
++ ew_res = A->ew_res;
++
++ if(regions_intersecion(A, B, &intersec) == -1)
++ return -1;
++
++ A_bounds->north = ceil((A->north - intersec.north - ns_res * 0.5) / ns_res);
++ A_bounds->south = ceil((A->north - intersec.south - ns_res * 0.5) / ns_res);
++
++ A_bounds->east = ceil((intersec.east - A->west - ew_res * 0.5) / ew_res);
++ A_bounds->west = ceil((intersec.west - A->west - ew_res * 0.5) / ew_res);
++
++ B_bounds->north = ceil((B->north - intersec.north - ns_res * 0.5) / ns_res);
++ B_bounds->south = ceil((B->north - intersec.south - ns_res * 0.5) / ns_res);
++
++ B_bounds->east = ceil((intersec.east - B->west - ew_res * 0.5) / ew_res);
++ B_bounds->west = ceil((intersec.west - B->west - ew_res * 0.5) / ew_res);
++
++ return 0;
++}
++
++/*!
++ \brief Insert raster map patch into pgm file.
++ Warning: calls Rast_set_window
++
++ \param patch_rast name of raster map
++ \param cat_rast_region region of category raster file
++ \param cat_rast path to category raster file
++
++ \return 0 on success
++ \return -1 on failure
++*/
++int I_insert_patch_to_cat_rast(const char * patch_rast, struct Cell_head * cat_rast_region, const char * cat_rast)
++{
++
++ FILE * f_cat_rast;
++ struct Cell_head patch_region, patch_bounds, cat_rast_bounds;
++ char cat_rast_header[1024];//TODO magic number
++ int i_row, i_col, ncols, nrows, cat_rast_col, patch_col, val;
++ int head_nchars, ret;
++ int fd_patch_rast, init_shift, step_shift;
++ unsigned char * patch_data;
++
++ char * null_chunk_row;
++
++ const char *mapset;
++
++ struct Cell_head patch_lines, cat_rast_lines;
++
++ unsigned char * row_data;
++
++ f_cat_rast = fopen(cat_rast, "rb+");
++ if(!f_cat_rast) {
++ G_warning(_("Unable to open category raster condtions file <%s>."), cat_rast);
++ return -1;
++ }
++
++ head_nchars = get_cat_rast_header(cat_rast_region, cat_rast_header);
++ if ((mapset = G_find_raster(patch_rast,"")) == NULL) {
++ fclose(f_cat_rast);
++ G_warning(_("Unable to find patch raster <%s>."), patch_rast);
++ return -1;
++ }
++
++ Rast_get_cellhd(patch_rast, mapset, &patch_region);
++ Rast_set_window(&patch_region);
++
++ if ((fd_patch_rast = Rast_open_old(patch_rast, mapset)) < 0) {
++ fclose(f_cat_rast);
++ return -1;
++ }
++
++ ret = get_rows_and_cols_bounds(cat_rast_region, &patch_region, &cat_rast_bounds, &patch_bounds);
++ if(ret == -2) {
++ G_warning(_("Resolutions of patch <%s> and patched file <%s> are not same."), patch_rast, cat_rast);
++
++ Rast_close(fd_patch_rast);
++ fclose(f_cat_rast);
++
++ return -1;
++ }
++ else if (ret == -1){
++
++ Rast_close(fd_patch_rast);
++ fclose(f_cat_rast);
++
++ return 0;
++ }
++
++ ncols = cat_rast_bounds.east - cat_rast_bounds.west;
++ nrows = cat_rast_bounds.south - cat_rast_bounds.north;
++
++ patch_data = (unsigned char *) G_malloc(ncols * sizeof(unsigned char));
++
++ init_shift = head_nchars + cat_rast_region->cols * cat_rast_bounds.north + cat_rast_bounds.west;
++
++ if(fseek(f_cat_rast, init_shift, SEEK_SET) != 0) {
++ G_warning(_("Corrupted category raster conditions file <%s> (fseek failed)"), cat_rast);
++
++ Rast_close(fd_patch_rast);
++ G_free(null_chunk_row);
++ fclose(f_cat_rast);
++
++ return -1;
++ }
++
++ step_shift = cat_rast_region->cols - ncols;
++
++ null_chunk_row = Rast_allocate_null_buf();
++
++ for(i_row = 0; i_row < nrows; i_row++) {
++ Rast_get_null_value_row (fd_patch_rast, null_chunk_row, i_row + patch_bounds.north);
++
++ for(i_col = 0; i_col < ncols; i_col++) {
++ patch_col = patch_bounds.west + i_col;
++
++ if(null_chunk_row[patch_col] != 1)
++ patch_data[i_col] = 1 & 255;
++ else {
++ patch_data[i_col] = 0 & 255;
++ }
++ }
++
++ fwrite(patch_data, sizeof(unsigned char), (ncols)/sizeof(unsigned char), f_cat_rast);
++ if (ferror(f_cat_rast))
++ {
++ G_warning(_("Unable to write into category raster conditions file <%s>"), cat_rast);
++
++ Rast_close(fd_patch_rast);
++ G_free(null_chunk_row);
++ fclose(f_cat_rast);
++
++ return -1;
++ }
++ if(fseek(f_cat_rast, step_shift, SEEK_CUR) != 0) {
++ G_warning(_("Corrupted category raster conditions file <%s> (fseek failed)"), cat_rast);
++
++ Rast_close(fd_patch_rast);
++ G_free(null_chunk_row);
++ fclose(f_cat_rast);
++
++ return -1;
++ }
++ }
++
++ Rast_close(fd_patch_rast);
++ G_free(null_chunk_row);
++ fclose(f_cat_rast);
++ return 0;
++}
++
++/*!
++ \brief Updates scatter plots data in category by pixels which meets category conditions.
++
++ \param bands_rows data represents data describig one row from raster band
++ \param belongs_pix array which defines which pixels belongs to category (1 value) and which not (0 value)
++ \param [out] scatts pointer to scScatts struct of type SC_SCATT_DATA, which are modified according to values in belongs_pix
++*/
++static inline void update_cat_scatt_plts(struct rast_row * bands_rows, unsigned short * belongs_pix, struct scScatts * scatts)
++{
++ int band_axis_1, band_axis_2, i_scatt, array_idx, cat_idx, i_chunk_rows_pix, max_arr_idx;
++
++ CELL * b_1_row;
++ CELL * b_2_row;
++ char * b_1_null_row,* b_2_null_row;
++ struct rast_row b_1_rast_row, b_2_rast_row;
++
++ struct Range b_1_range, b_2_range;
++ int b_1_range_size;
++
++ int row_size = Rast_window_cols();
++
++ int * scatts_bands = scatts->scatts_bands;
++
++ for(i_scatt = 0; i_scatt < scatts->n_a_scatts; i_scatt++)
++ {
++ b_1_rast_row = bands_rows[scatts_bands[i_scatt * 2]];
++ b_2_rast_row = bands_rows[scatts_bands[i_scatt * 2 + 1]];
++
++ b_1_row = b_1_rast_row.row;
++ b_2_row = b_2_rast_row.row;
++
++ b_1_null_row = b_1_rast_row.null_row;
++ b_2_null_row = b_2_rast_row.null_row;
++
++ b_1_range = b_1_rast_row.rast_range;
++ b_2_range = b_2_rast_row.rast_range;
++
++ b_1_range_size = b_1_range.max - b_1_range.min + 1;
++ max_arr_idx = (b_1_range.max - b_1_range.min + 1) * (b_2_range.max - b_2_range.min + 1);
++
++ for(i_chunk_rows_pix = 0; i_chunk_rows_pix < row_size; i_chunk_rows_pix++)
++ {
++ /* pixel does not belongs to scatter plot or has null value in one of the bands */
++ if(!belongs_pix[i_chunk_rows_pix] ||
++ b_1_null_row[i_chunk_rows_pix] == 1 ||
++ b_2_null_row[i_chunk_rows_pix] == 1)
++ continue;
++
++ /* index in scatter plot array */
++ array_idx = b_1_row[i_chunk_rows_pix] - b_1_range.min + (b_2_row[i_chunk_rows_pix] - b_2_range.min) * b_1_range_size;
++
++ if(array_idx < 0 || array_idx >= max_arr_idx) {
++ G_warning ("Data inconsistent. Value computed for scatter plot is out of initialized range.");
++ continue;
++ }
++
++ /* increment scatter plot value */
++ ++scatts->scatts_arr[i_scatt]->scatt_vals_arr[array_idx];
++ }
++ }
++}
++
++/*!
++ \brief Computes scatter plots data from chunk_rows.
++
++ \param scatts pointer to scScatts struct of type SC_SCATT_DATA, where are computed scatter plots stored
++ \param scatt_conds pointer to scScatts struct of type SC_SCATT_CONDITIONS, where are selected areas (condtitions)stored
++
++ \param chunk_rows data arrays of chunk_rows from analyzed raster bands (all data in chunk_rows, null_chunk_rows and belongs_pix arrays represents same region)
++ \param null_chunk_rows null data arrays of chunk_rows from analyzed raster bands
++ \param row_size size of data in chunk_rows, null_chunk_rows and belongs_pix arrays
++ \param f_cats_rasts_conds file which stores selected areas (conditions) from mapwindow see I_create_cat_rast() and I_pa
++ \param fd_cats_rasts array of openedraster maps which represents all selected pixels for category
++ \param region analysis region
++
++ \return 0 on success
++ \return -1 on failure
++*/
++static inline int compute_scatts_from_chunk_row(struct Cell_head *region, struct scCats * scatt_conds,
++ FILE ** f_cats_rasts_conds, struct rast_row * bands_rows,
++ struct scCats * scatts, int * fd_cats_rasts)
++{
++
++ int i_rows_pix, i_cat, i_scatt, n_a_scatts, n_pixs;
++ int cat_id, scatt_plts_cat_idx, array_idx, max_arr_idx;
++ char * b_1_null_row,* b_2_null_row;
++ struct rast_row b_1_rast_row, b_2_rast_row;
++ CELL * cat_rast_row;
++
++ struct scScatts * scatts_conds;
++ struct scScatts * scatts_scatt_plts;
++ struct scdScattData * conds;
++
++ struct Range b_1_range, b_2_range;
++ int b_1_range_size;
++
++ int * scatts_bands;
++ struct scdScattData ** scatts_arr;
++
++ CELL * b_1_row;
++ CELL * b_2_row;
++ unsigned char * i_scatt_conds;
++
++ int row_size = Rast_window_cols();
++
++ unsigned short * belongs_pix = (unsigned short *) G_malloc(row_size * sizeof(unsigned short));
++ unsigned char * rast_pixs = (unsigned char *) G_malloc(row_size * sizeof(unsigned char));
++ cat_rast_row = Rast_allocate_c_buf();
++
++
++ for(i_cat = 0; i_cat < scatt_conds->n_a_cats; i_cat++)
++ {
++ scatts_conds = scatt_conds->cats_arr[i_cat];
++
++ cat_id = scatt_conds->cats_ids[i_cat];
++
++ scatt_plts_cat_idx = scatts->cats_idxs[cat_id];
++ if(scatt_plts_cat_idx < 0)
++ continue;
++ scatts_scatt_plts = scatts->cats_arr[scatt_plts_cat_idx];
++
++ G_zero(belongs_pix, row_size * sizeof(unsigned short));
++
++ /* if category has no conditions defined, scatter plots without any constraint are computed (default scatter plots) */
++ if(!scatts_conds->n_a_scatts && !f_cats_rasts_conds[i_cat]) {
++ for(i_scatt = 0; i_scatt < scatts_scatt_plts->n_a_scatts; i_scatt++)
++ {
++ /* all pixels belongs */
++ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
++ belongs_pix[i_rows_pix] = 1;
++ }
++ }
++ /* compute belonging pixels for defined conditions */
++ else
++ {
++ scatts_bands = scatts_conds->scatts_bands;
++
++ /* check conditions from category raster condtitions file */
++ if(f_cats_rasts_conds[i_cat]) {
++ n_pixs = fread(rast_pixs, sizeof(unsigned char), (row_size)/sizeof(unsigned char), f_cats_rasts_conds[i_cat]);
++
++ if (ferror(f_cats_rasts_conds[i_cat]))
++ {
++ G_free(rast_pixs);
++ G_free(belongs_pix);
++ G_warning(_("Unable to read from category raster condtition file."));
++ return -1;
++ }
++ if (n_pixs != n_pixs) {
++ G_free(rast_pixs);
++ G_free(belongs_pix);
++ G_warning(_("Invalid size of category raster conditions file."));
++ return -1;
++
++ }
++
++ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
++ {
++ if(rast_pixs[i_rows_pix] != 0 & 255)
++ belongs_pix[i_rows_pix] = 1;
++ }
++ }
++
++ /* check condtions defined in scatter plots*/
++ for(i_scatt = 0; i_scatt < scatts_conds->n_a_scatts; i_scatt++)
++ {
++ b_1_rast_row = bands_rows[scatts_bands[i_scatt * 2]];
++ b_2_rast_row = bands_rows[scatts_bands[i_scatt * 2 + 1]];
++
++ b_1_row = b_1_rast_row.row;
++ b_2_row = b_2_rast_row.row;
++
++ b_1_null_row = b_1_rast_row.null_row;
++ b_2_null_row = b_2_rast_row.null_row;
++
++ b_1_range = b_1_rast_row.rast_range;
++ b_2_range = b_2_rast_row.rast_range;
++
++ b_1_range_size = b_1_range.max - b_1_range.min + 1;
++ max_arr_idx = (b_1_range.max - b_1_range.min + 1) * (b_2_range.max - b_2_range.min + 1);
++
++ i_scatt_conds = scatts_conds->scatts_arr[i_scatt]->b_conds_arr;
++
++ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
++ {
++ /* pixels already belongs to category from category raster conditions file or contains null value in one of the bands */
++ if(belongs_pix[i_rows_pix] ||
++ b_1_null_row[i_rows_pix] == 1 ||
++ b_2_null_row[i_rows_pix] == 1)
++ continue;
++
++ array_idx = b_1_row[i_rows_pix] - b_1_range.min + (b_2_row[i_rows_pix] - b_2_range.min) * b_1_range_size;
++ if(array_idx < 0 || array_idx >= max_arr_idx) {
++ G_warning ("Data inconsistent. Value computed for scatter plot is out of initialized range.");
++ continue;
++ }
++ /* pixels meets condtion defined in scatter plot */
++ if(i_scatt_conds[array_idx])
++ belongs_pix[i_rows_pix] = 1;
++ }
++ }
++ }
++
++ /* update category raster with belonging pixels */
++ if(fd_cats_rasts[i_cat] >= 0) {
++ Rast_set_null_value(cat_rast_row, Rast_window_cols(), CELL_TYPE);
++
++ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
++ if(belongs_pix[i_rows_pix])
++ cat_rast_row[i_rows_pix] = belongs_pix[i_rows_pix];
++
++ Rast_put_c_row (fd_cats_rasts[i_cat], cat_rast_row);
++ }
++
++ /* update scatter plots with belonging pixels */
++ update_cat_scatt_plts(bands_rows, belongs_pix, scatts_scatt_plts);
++ }
++
++ G_free(cat_rast_row);
++ G_free(rast_pixs);
++ G_free(belongs_pix);
++
++ return 0;
++}
++
++/*!
++ \brief Get list if bands needed to be opened for analysis from scCats struct.
++*/
++static void get_needed_bands(struct scCats * cats, int * b_needed_bands)
++{
++ // results in b_needed_bands - array of bools - if item has value 1, band (defined by item index) is needed to be opened
++ int i_cat, i_scatt, cat_id;
++
++ for(i_cat = 0; i_cat < cats->n_a_cats; i_cat++)
++ {
++ for(i_scatt = 0; i_scatt < cats->cats_arr[i_cat]->n_a_scatts; i_scatt++)
++ {
++ G_debug(3, "Active scatt %d in catt %d", i_scatt, i_cat);
++
++ b_needed_bands[cats->cats_arr[i_cat]->scatts_bands[i_scatt * 2]] = 1;
++ b_needed_bands[cats->cats_arr[i_cat]->scatts_bands[i_scatt * 2 + 1]] = 1;
++ }
++ }
++ return;
++}
++
++/*!
++ \brief Helper function for clean up.
++*/
++static void free_compute_scatts_data(int * fd_bands, struct rast_row * bands_rows, int n_a_bands, int * bands_ids,
++ int * fd_cats_rasts, FILE ** f_cats_rasts_conds, int n_a_cats)
++{
++ int i, band_id;
++
++ for(i = 0; i < n_a_bands; i++)
++ {
++ band_id = bands_ids[i];
++ if(band_id >= 0) {
++ Rast_close(fd_bands[i]);
++ G_free(bands_rows[band_id].row);
++ G_free(bands_rows[band_id].null_row);
++ }
++ }
++
++ if(f_cats_rasts_conds)
++ for(i = 0; i < n_a_cats; i++)
++ if(f_cats_rasts_conds[i])
++ fclose(f_cats_rasts_conds[i]);
++
++ if(fd_cats_rasts)
++ for(i = 0; i < n_a_cats; i++)
++ if(fd_cats_rasts[i] >= 0)
++ Rast_close(fd_cats_rasts[i]);
++
++}
++
++/*!
++ \brief Compute scatter plots data.
++
++ If category has not defined no category raster condition file and no scatter plot with consdtion,
++ default scatter plot is computed.
++ Warning: calls Rast_set_window
++
++ \param region analysis region, beaware that all input data must be prepared for this region (bands (their ranges), cats_rasts_conds rasters...)
++ \param region function calls Rast_set_window for this region
++ \param scatt_conds pointer to scScatts struct of type SC_SCATT_CONDITIONS, where are stored selected areas (conditions) in scatter plots
++ \param cats_rasts_conds paths to category raster conditions files representing selected areas (conditions) in rasters for every category
++ \param cats_rasts_conds index in array represents corresponding category id
++ \param cats_rasts_conds for manupulation with category raster conditions file see also I_id_scatt_to_bands() and I_insert_patch_to_cat_rast()
++ \param bands names of analyzed bands, order of bands is defined by their id
++ \param n_bands number of bands
++ \param [out] scatts pointer to scScatts struct of type SC_SCATT_DATA, where are computed scatter plots stored
++ \param [out] cats_rasts array of raster maps names where will be stored all selected pixels for every category
++
++ \return 0 on success
++ \return -1 on failure
++*/
++int I_compute_scatts(struct Cell_head *region, struct scCats * scatt_conds, const char ** cats_rasts_conds,
++ const char ** bands, int n_bands, struct scCats * scatts, const char ** cats_rasts)
++{
++ const char *mapset;
++ char header[1024];
++
++ int fd_cats_rasts[scatt_conds->n_a_cats];
++ FILE * f_cats_rasts_conds[scatt_conds->n_a_cats];
++
++ struct rast_row bands_rows[n_bands];
++
++ RASTER_MAP_TYPE data_type;
++
++ int nrows, i_band, n_a_bands, band_id,
++ i, i_row, head_nchars, i_cat, id_cat;
++
++ int fd_bands[n_bands];
++ int bands_ids[n_bands];
++ int b_needed_bands[n_bands];
++
++ Rast_set_window(region);
++
++ for(i_band = 0; i_band < n_bands; i_band++)
++ fd_bands[i_band] = -1;
++
++ for(i_band = 0; i_band < n_bands; i_band++)
++ bands_ids[i_band] = -1;
++
++ if (n_bands != scatts->n_bands ||
++ n_bands != scatt_conds->n_bands)
++ return -1;
++
++ memset(b_needed_bands, 0, (size_t)n_bands * sizeof(int));
++
++ get_needed_bands(scatt_conds, &b_needed_bands[0]);
++ get_needed_bands(scatts, &b_needed_bands[0]);
++
++ n_a_bands = 0;
++
++ /* open band rasters, which are needed for computation */
++ for(band_id = 0; band_id < n_bands; band_id++)
++ {
++ if(b_needed_bands[band_id])
++ {
++ G_debug(3, "Opening raster no. %d with name: %s", band_id, bands[band_id]);
++
++ if ((mapset = G_find_raster2(bands[band_id],"")) == NULL) {
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
++ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
++ G_warning(_("Unbale to read find raster <%s>"), bands[band_id]);
++ return -1;
++ }
++
++ if ((fd_bands[n_a_bands] = Rast_open_old(bands[band_id], mapset)) < 0) {
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
++ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
++ G_warning(_("Unbale to open raster <%s>"), bands[band_id]);
++ return -1;
++ }
++
++ data_type = Rast_get_map_type(fd_bands[n_a_bands]);
++ if(data_type != CELL_TYPE) {
++ G_warning(_("Raster <%s> type is not <%s>"), bands[band_id], "CELL");
++ return -1;
++ }
++
++ bands_rows[band_id].row = Rast_allocate_c_buf();
++ bands_rows[band_id].null_row = Rast_allocate_null_buf();
++
++ if(Rast_read_range(bands[band_id], mapset, &bands_rows[band_id].rast_range) != 1){
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
++ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
++ G_warning(_("Unable to read range of raster <%s>"), bands[band_id]);
++ return -1;
++ }
++
++ bands_ids[n_a_bands] = band_id;
++ ++n_a_bands;
++ }
++ }
++
++ /* open category rasters condition files and category rasters */
++ for(i_cat = 0; i_cat < scatts->n_a_cats; i_cat++)
++ {
++ id_cat = scatts->cats_ids[i_cat];
++ if(cats_rasts[id_cat]) {
++ fd_cats_rasts[i_cat] = Rast_open_new(cats_rasts[id_cat], CELL_TYPE);
++ }
++ else
++ fd_cats_rasts[i_cat] = -1;
++
++ if(cats_rasts_conds[id_cat]) {
++ f_cats_rasts_conds[i_cat] = fopen(cats_rasts_conds[id_cat], "r");
++ if(!f_cats_rasts_conds[i_cat]) {
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids,
++ f_cats_rasts_conds, f_cats_rasts_conds, scatt_conds->n_a_cats);
++ G_warning(_("Unable to open category raster condtition file <%s>"), bands[band_id]);
++ return -1;
++ }
++ }
++ else
++ f_cats_rasts_conds[i_cat] = NULL;
++ }
++
++ head_nchars = get_cat_rast_header(region, header);
++ for(i_cat = 0; i_cat < scatt_conds->n_a_cats; i_cat++)
++ if(f_cats_rasts_conds[i_cat])
++ if( fseek(f_cats_rasts_conds[i_cat] , head_nchars, SEEK_SET) != 0) {
++ G_warning(_("Corrupted category raster conditions file (fseek failed)"));
++ return -1;
++ }
++
++ nrows = Rast_window_rows();
++
++ /* analyze bands by rows */
++ for (i_row = 0; i_row < nrows; i_row++)
++ {
++ for(i_band = 0; i_band < n_a_bands; i_band++)
++ {
++ band_id = bands_ids[i_band];
++ Rast_get_c_row(fd_bands[i_band], bands_rows[band_id].row, i_row);
++ Rast_get_null_value_row (fd_bands[i_band], bands_rows[band_id].null_row, i_row);
++ }
++ if(compute_scatts_from_chunk_row(region, scatt_conds, f_cats_rasts_conds, bands_rows, scatts, fd_cats_rasts) == -1)
++ {
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids, fd_cats_rasts,
++ f_cats_rasts_conds, scatt_conds->n_a_cats);
++ return -1;
++ }
++
++ }
++ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids,
++ fd_cats_rasts, f_cats_rasts_conds, scatt_conds->n_a_cats);
++ return 0;
++}
++
++/*!
++ \brief Merge arrays according to opacity.
++ Every pixel in array must be represented by 4 values (RGBA).
++
++
++ \param merged_arr array which will be overlayd with overlay_arr
++ \param overlay_arr array to be merged_arr overlayed with
++ \param rows number of rows for the both arrays
++ \param cols number of columns for the both arrays
++ \param alpha transparency of the overlay array for merging
++
++ \return 0
++*/
++int I_merge_arrays(unsigned char * merged_arr, unsigned char * overlay_arr, unsigned rows, unsigned cols, double alpha)
++{
++ unsigned int i_row, i_col, i_b;
++ unsigned int row_idx, col_idx, idx;
++ unsigned int c_a_i, c_a;
++
++ for(i_row = 0; i_row < rows; i_row++)
++ {
++ row_idx = i_row * cols;
++ for(i_col = 0; i_col < cols; i_col++)
++ {
++ col_idx = 4 * (row_idx + i_col);
++ idx = col_idx + 3;
++
++ c_a = overlay_arr[idx] * alpha;
++ c_a_i = 255 - c_a;
++
++ merged_arr[idx] = (c_a_i * (int)merged_arr[idx] + c_a * 255) / 255;
++
++ for(i_b = 0; i_b < 3; i_b++)
++ {
++ idx = col_idx + i_b;
++ merged_arr[idx] = (c_a_i * (int)merged_arr[idx] + c_a * (int)overlay_arr[idx]) / 255;
++ }
++ }
++ }
++ return 0;
++}
++
++
++int I_apply_colormap(unsigned char * vals, unsigned char * vals_mask, unsigned vals_size, unsigned char * colmap, unsigned char * col_vals){
++ unsigned int i_val;
++ int v, i, i_cm;
++
++ for(i_val = 0; i_val < vals_size; i_val++){
++ i_cm = 4 * i_val;
++
++ v = vals[i_val];
++
++ if(vals_mask && vals_mask[i_val])
++ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[258 * 4 + i];
++ else if(v > 255)
++ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[257 * 4 + i];
++ else if(v < 0)
++ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[256 * 4 + i];
++ else
++ for(i = 0; i < 4; i++){ col_vals[i_cm + i] = colmap[v * 4 + i];
++ }
++ }
++ return 0;
++}
++
++
++int I_rasterize(double * polygon, int pol_n_pts, unsigned char * rast, unsigned char val, struct Cell_head *rast_region){
++ int i;
++ int x0, x1, y;
++ int row, row_idx, i_col;
++
++ IClass_perimeter perimeter;
++
++ struct line_pnts *pol;
++ pol = Vect_new_line_struct();
++
++ for(i = 0; i < pol_n_pts; i++) {
++ Vect_append_point(pol,
++ polygon[i*2],
++ polygon[i*2 + 1],
++ 0.0);
++ }
++
++ Rast_set_window(rast_region);
++
++ make_perimeter(pol, &perimeter, rast_region);
++ for (i = 1; i < perimeter.npoints; i += 2) {
++ y = perimeter.points[i].y;
++ if (y != perimeter.points[i - 1].y) {
++ G_warning(_("prepare_signature: scan line %d has odd number of points."),
++ (i + 1) / 2);
++ return 1;
++ }
++
++ x0 = perimeter.points[i - 1].x;
++ x1 = perimeter.points[i].x;
++
++ if (x0 > x1) {
++ G_warning(_("signature: perimeter points out of order."));
++ return 1;
++ }
++
++ row = (rast_region->rows - y);
++ if(row < 0 || row >= rast_region->rows) {
++ continue;
++ }
++
++ row_idx = rast_region->cols * row;
++
++ for(i_col = x0; i_col <= x1; i_col++) {
++ if(i_col < 0 || i_col >= rast_region->cols) {
++ continue;
++ }
++ rast[row_idx + i_col] = val;
++ }
++ }
++
++ Vect_destroy_line_struct(pol);
++ G_free(perimeter.points);
++ return 0;
++}
+Index: include/defs/vedit.h
+===================================================================
+--- include/defs/vedit.h (revision 57747)
++++ include/defs/vedit.h (working copy)
+@@ -33,6 +33,8 @@
+ int Vedit_merge_lines(struct Map_info *, struct ilist *);
+
+ /* move.c */
++int Vedit_move_areas(struct Map_info *, struct Map_info **, int,
++ struct ilist *, double, double, double, int, double);
+ int Vedit_move_lines(struct Map_info *, struct Map_info **, int,
+ struct ilist *, double, double, double, int, double);
+
Index: include/defs/imagery.h
===================================================================
---- include/defs/imagery.h (revision 57734)
+--- include/defs/imagery.h (revision 57747)
+++ include/defs/imagery.h (working copy)
@@ -111,6 +111,28 @@
FILE *I_fopen_subgroup_ref_new(const char *, const char *);
@@ -31,22 +1330,9 @@
/* sig.c */
int I_init_signatures(struct Signature *, int);
int I_new_signature(struct Signature *);
-Index: include/defs/vedit.h
-===================================================================
---- include/defs/vedit.h (revision 57734)
-+++ include/defs/vedit.h (working copy)
-@@ -33,6 +33,8 @@
- int Vedit_merge_lines(struct Map_info *, struct ilist *);
-
- /* move.c */
-+int Vedit_move_areas(struct Map_info *, struct Map_info **, int,
-+ struct ilist *, double, double, double, int, double);
- int Vedit_move_lines(struct Map_info *, struct Map_info **, int,
- struct ilist *, double, double, double, int, double);
-
Index: include/imagery.h
===================================================================
---- include/imagery.h (revision 57734)
+--- include/imagery.h (revision 57747)
+++ include/imagery.h (working copy)
@@ -135,6 +135,56 @@
@@ -105,9 +1391,573 @@
#define SIGNATURE_TYPE_MIXED 1
#define GROUPFILE "CURGROUP"
+Index: gui/icons/grass/polygon.png
+===================================================================
+Cannot display: file marked as a binary type.
+svn:mime-type = application/octet-stream
+Index: gui/icons/grass/polygon.png
+===================================================================
+--- gui/icons/grass/polygon.png (revision 57747)
++++ gui/icons/grass/polygon.png (working copy)
+
+Property changes on: gui/icons/grass/polygon.png
+___________________________________________________________________
+Added: svn:mime-type
+## -0,0 +1 ##
++application/octet-stream
+\ No newline at end of property
+Index: gui/wxpython/vdigit/wxdigit.py
+===================================================================
+--- gui/wxpython/vdigit/wxdigit.py (revision 57747)
++++ gui/wxpython/vdigit/wxdigit.py (working copy)
+@@ -17,7 +17,7 @@
+ (and NumPy would be an excellent candidate for acceleration via
+ e.g. OpenCL or CUDA; I'm surprised it hasn't happened already).
+
+-(C) 2007-2011 by the GRASS Development Team
++(C) 2007-2011, 2013 by the GRASS Development Team
+
+ This program is free software under the GNU General Public License
+ (>=v2). Read the file COPYING that comes with GRASS for details.
+@@ -27,6 +27,8 @@
+
+ import grass.script.core as grass
+
++from grass.pydispatch.signal import Signal
++
+ from core.gcmd import GError
+ from core.debug import Debug
+ from core.settings import UserSettings
+@@ -176,7 +178,21 @@
+
+ if self.poMapInfo:
+ self.InitCats()
+-
++
++ self.emit_signals = False
++
++ # signals which describes features changes during digitization,
++ # activate them using EmitSignals method
++ #TODO signal for errors?
++ self.featureAdded = Signal('IVDigit.featureAdded')
++ self.areasDeleted = Signal('IVDigit.areasDeleted')
++ self.vertexMoved = Signal('IVDigit.vertexMoved')
++ self.vertexAdded = Signal('IVDigit.vertexAdded')
++ self.vertexRemoved = Signal('IVDigit.vertexRemoved')
++ self.featuresDeleted = Signal('IVDigit.featuresDeleted')
++ self.featuresMoved = Signal('IVDigit.featuresMoved')
++ self.lineEdited = Signal('IVDigit.lineEdited')
++
+ def __del__(self):
+ Debug.msg(1, "IVDigit.__del__()")
+ Vect_destroy_line_struct(self.poPoints)
+@@ -188,7 +204,12 @@
+ Vect_close(self.poBgMapInfo)
+ self.poBgMapInfo = self.popoBgMapInfo = None
+ del self.bgMapInfo
+-
++
++ def EmitSignals(self, emit):
++ """!Activate/deactivate signals which describes features changes during digitization.
++ """
++ self.emit_signals = emit
++
+ def CloseBackgroundMap(self):
+ """!Close background vector map"""
+ if not self.poBgMapInfo:
+@@ -394,7 +415,6 @@
+
+ @return tuple (number of added features, feature ids)
+ """
+-
+ layer = self._getNewFeaturesLayer()
+ cat = self._getNewFeaturesCat()
+
+@@ -419,10 +439,14 @@
+ return (-1, None)
+
+ self.toolbar.EnableUndo()
+-
+- return self._addFeature(vtype, points, layer, cat,
+- self._getSnapMode(), self._display.GetThreshold())
+-
++
++ ret = self._addFeature(vtype, points, layer, cat,
++ self._getSnapMode(), self._display.GetThreshold())
++ if ret[0] > -1 and self.emit_signals:
++ self.featureAdded.emit(new_bboxs = [self._createBbox(points)], new_areas_cats = [[{layer : [cat]}, None]])
++
++ return ret
++
+ def DeleteSelectedLines(self):
+ """!Delete selected features
+
+@@ -434,16 +458,27 @@
+ # collect categories for deleting if requested
+ deleteRec = UserSettings.Get(group = 'vdigit', key = 'delRecord', subkey = 'enabled')
+ catDict = dict()
++
++ old_bboxs = []
++ old_areas_cats = []
+ if deleteRec:
+ for i in self._display.selected['ids']:
++
+ if Vect_read_line(self.poMapInfo, None, self.poCats, i) < 0:
+ self._error.ReadLine(i)
+
+- cats = self.poCats.contents
+- for j in range(cats.n_cats):
+- if cats.field[j] not in catDict.keys():
+- catDict[cats.field[j]] = list()
+- catDict[cats.field[j]].append(cats.cat[j])
++ if self.emit_signals:
++ ret = self._getLineAreaBboxCats(i)
++ if ret:
++ old_bboxs += ret[0]
++ old_areas_cats += ret[1]
++
++ # catDict was not used -> put into comment
++ #cats = self.poCats.contents
++ #for j in range(cats.n_cats):
++ # if cats.field[j] not in catDict.keys():
++ # catDict[cats.field[j]] = list()
++ # catDict[cats.field[j]].append(cats.cat[j])
+
+ poList = self._display.GetSelectedIList()
+ nlines = Vedit_delete_lines(self.poMapInfo, poList)
+@@ -456,7 +491,10 @@
+ self._deleteRecords(catDict)
+ self._addChangeset()
+ self.toolbar.EnableUndo()
+-
++
++ if self.emit_signals:
++ self.featuresDeleted.emit(old_bboxs = old_bboxs, old_areas_cats = old_areas_cats)
++
+ return nlines
+
+ def _deleteRecords(self, cats):
+@@ -512,22 +550,173 @@
+
+ @return number of deleted
+ """
++ if len(self._display.selected['ids']) < 1:
++ return 0
++
+ poList = self._display.GetSelectedIList()
+ cList = poList.contents
+
+ nareas = 0
++ old_bboxs = []
++ old_areas_cats = []
++
+ for i in range(cList.n_values):
++
+ if Vect_get_line_type(self.poMapInfo, cList.value[i]) != GV_CENTROID:
+ continue
+-
++
++ if self.emit_signals:
++ area = Vect_get_centroid_area(self.poMapInfo, cList.value[i]);
++ if area > 0:
++ bbox, cats = self._getaAreaBboxCats(area)
++ old_bboxs += bbox
++ old_areas_cats += cats
++
+ nareas += Vedit_delete_area_centroid(self.poMapInfo, cList.value[i])
+
+ if nareas > 0:
+ self._addChangeset()
+ self.toolbar.EnableUndo()
++ if self.emit_signals:
++ self.areasDeleted.emit(old_bboxs = old_bboxs, old_areas_cats = old_areas_cats)
++
++ return nareas
++
++ def _getLineAreaBboxCats(self, ln_id):
++ ltype = Vect_read_line(self.poMapInfo, None, None, ln_id)
++
++ if ltype == GV_CENTROID:
++ #TODO centroid opttimization, can be adited also its area -> it will appear two times in new_ lists
++ return self._getCentroidAreaBboxCats(ln_id)
++ else:
++ return [self._getBbox(ln_id)], [self._getLineAreasCategories(ln_id)]
++
++
++ def _getCentroidAreaBboxCats(self, centroid):
++ if not Vect_line_alive(self.poMapInfo, centroid):
++ return None
++
++ area = Vect_get_centroid_area(self.poMapInfo, centroid)
++ if area > 0:
++ return self._getaAreaBboxCats(area)
++ else:
++ return None
++
++ def _getaAreaBboxCats(self, area):
++
++ po_b_list = Vect_new_list()
++ Vect_get_area_boundaries(self.poMapInfo, area, po_b_list);
++ b_list = po_b_list.contents
++
++ geoms = []
++ areas_cats = []
++
++ if b_list.n_values > 0:
++ for i_line in range(b_list.n_values):
++
++ line = b_list.value[i_line];
++
++ geoms.append(self._getBbox(abs(line)))
++ areas_cats.append(self._getLineAreasCategories(abs(line)))
+
+- return nareas
++ Vect_destroy_list(po_b_list);
++
++ return geoms, areas_cats
++
++ def _getLineAreasCategories(self, ln_id):
++ if not Vect_line_alive (self.poMapInfo, ln_id):
++ return []
++
++ ltype = Vect_read_line(self.poMapInfo, None, None, ln_id)
++ if ltype != GV_BOUNDARY:
++ return []
++
++ cats = [None, None]
++
++ left = c_int()
++ right = c_int()
++
++ if Vect_get_line_areas(self.poMapInfo, ln_id, pointer(left), pointer(right)) == 1:
++ areas = [left.value, right.value]
++
++ for i, a in enumerate(areas):
++ if a > 0:
++ centroid = Vect_get_area_centroid(self.poMapInfo, a)
++ if centroid <= 0:
++ continue
++ c = self._getCategories(centroid)
++ if c:
++ cats[i] = c
++
++ return cats
++
++ def _getCategories(self, ln_id):
++ if not Vect_line_alive (self.poMapInfo, ln_id):
++ return none
++
++ poCats = Vect_new_cats_struct()
++ if Vect_read_line(self.poMapInfo, None, poCats, ln_id) < 0:
++ Vect_destroy_cats_struct(poCats)
++ return None
++
++ cCats = poCats.contents
++
++ cats = {}
++ for j in range(cCats.n_cats):
++ if cats.has_key(cCats.field[j]):
++ cats[cCats.field[j]].append(cCats.cat[j])
++ else:
++ cats[cCats.field[j]] = [cCats.cat[j]]
+
++ Vect_destroy_cats_struct(poCats)
++ return cats
++
++ def _getBbox(self, ln_id):
++ if not Vect_line_alive (self.poMapInfo, ln_id):
++ return None
++
++ poPoints = Vect_new_line_struct()
++ if Vect_read_line(self.poMapInfo, poPoints, None, ln_id) < 0:
++ Vect_destroy_line_struct(poPoints)
++ return []
++
++ geom = self._convertGeom(poPoints)
++ bbox = self._createBbox(geom)
++ Vect_destroy_line_struct(poPoints)
++ return bbox
++
++ def _createBbox(self, points):
++
++ bbox = {}
++ for pt in points:
++ if not bbox.has_key('maxy'):
++ bbox['maxy'] = pt[1]
++ bbox['miny'] = pt[1]
++ bbox['maxx'] = pt[0]
++ bbox['minx'] = pt[0]
++ continue
++
++ if bbox['maxy'] < pt[1]:
++ bbox['maxy'] = pt[1]
++ elif bbox['miny'] > pt[1]:
++ bbox['miny'] = pt[1]
++
++ if bbox['maxx'] < pt[0]:
++ bbox['maxx'] = pt[0]
++ elif bbox['minx'] > pt[0]:
++ bbox['minx'] = pt[0]
++ return bbox
++
++ def _convertGeom(self, poPoints):
++
++ Points = poPoints.contents
++
++ pts_geom = []
++ for j in range(Points.n_points):
++ pts_geom.append((Points.x[j], Points.y[j]))
++
++ return pts_geom
++
+ def MoveSelectedLines(self, move):
+ """!Move selected features
+
+@@ -536,16 +725,45 @@
+ if not self._checkMap():
+ return -1
+
++ nsel = len(self._display.selected['ids'])
++ if nsel < 1:
++ return -1
++
+ thresh = self._display.GetThreshold()
+ snap = self._getSnapMode()
+
+ poList = self._display.GetSelectedIList()
++
++ if self.emit_signals:
++ old_bboxs = []
++ old_areas_cats = []
++ for sel_id in self._display.selected['ids']:
++ ret = self._getLineAreaBboxCats(sel_id)
++ if ret:
++ old_bboxs += ret[0]
++ old_areas_cats += ret[1]
++
++ Vect_set_updated(self.poMapInfo, 1)
++ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
++
+ nlines = Vedit_move_lines(self.poMapInfo, self.popoBgMapInfo, int(self.poBgMapInfo is not None),
+ poList,
+ move[0], move[1], 0,
+ snap, thresh)
++
+ Vect_destroy_list(poList)
+-
++
++ if nlines > 0 and self.emit_signals:
++ new_bboxs = []
++ new_areas_cats = []
++ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
++ for i in range(n_up_lines_old, n_up_lines):
++ new_id = Vect_get_updated_line(self.poMapInfo, i)
++ ret = self._getLineAreaBboxCats(new_id)
++ if ret:
++ new_bboxs += ret[0]
++ new_areas_cats += ret[1]
++
+ if nlines > 0 and self._settings['breakLines']:
+ for i in range(1, nlines):
+ self._breakLineAtIntersection(nlines + i, None, changeset)
+@@ -553,7 +771,13 @@
+ if nlines > 0:
+ self._addChangeset()
+ self.toolbar.EnableUndo()
+-
++
++ if self.emit_signals:
++ self.featuresMoved.emit(new_bboxs = new_bboxs,
++ old_bboxs = old_bboxs,
++ old_areas_cats = old_areas_cats,
++ new_areas_cats = new_areas_cats)
++
+ return nlines
+
+ def MoveSelectedVertex(self, point, move):
+@@ -571,12 +795,21 @@
+
+ if len(self._display.selected['ids']) != 1:
+ return -1
+-
++
++ # move only first found vertex in bbox
++ poList = self._display.GetSelectedIList()
++
++ if self.emit_signals:
++ cList = poList.contents
++ old_bboxs = [self._getBbox(cList.value[0])]
++ old_areas_cats = [self._getLineAreasCategories(cList.value[0])]
++
++ Vect_set_updated(self.poMapInfo, 1)
++ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
++
+ Vect_reset_line(self.poPoints)
+ Vect_append_point(self.poPoints, point[0], point[1], 0.0)
+-
+- # move only first found vertex in bbox
+- poList = self._display.GetSelectedIList()
++
+ moved = Vedit_move_vertex(self.poMapInfo, self.popoBgMapInfo, int(self.poBgMapInfo is not None),
+ poList, self.poPoints,
+ self._display.GetThreshold(type = 'selectThresh'),
+@@ -584,7 +817,17 @@
+ move[0], move[1], 0.0,
+ 1, self._getSnapMode())
+ Vect_destroy_list(poList)
+-
++
++ if moved > 0 and self.emit_signals:
++ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
++
++ new_bboxs = []
++ new_areas_cats = []
++ for i in range(n_up_lines_old, n_up_lines):
++ new_id = Vect_get_updated_line(self.poMapInfo, i)
++ new_bboxs.append(self._getBbox(new_id))
++ new_areas_cats.append(self._getLineAreasCategories(new_id))
++
+ if moved > 0 and self._settings['breakLines']:
+ self._breakLineAtIntersection(Vect_get_num_lines(self.poMapInfo),
+ None)
+@@ -592,7 +835,13 @@
+ if moved > 0:
+ self._addChangeset()
+ self.toolbar.EnableUndo()
+-
++
++ if self.emit_signals:
++ self.vertexMoved.emit(new_bboxs = new_bboxs,
++ new_areas_cats = new_areas_cats,
++ old_areas_cats = old_areas_cats,
++ old_bboxs = old_bboxs)
++
+ return moved
+
+ def AddVertex(self, coords):
+@@ -681,6 +930,10 @@
+ self._error.ReadLine(line)
+ return -1
+
++ if self.emit_signals:
++ old_bboxs = [self._getBbox(line)]
++ old_areas_cats = [self._getLineAreasCategories(line)]
++
+ # build feature geometry
+ Vect_reset_line(self.poPoints)
+ for p in coords:
+@@ -696,6 +949,9 @@
+
+ newline = Vect_rewrite_line(self.poMapInfo, line, ltype,
+ self.poPoints, self.poCats)
++ if newline > 0 and self.emit_signals:
++ new_geom = [self._getBbox(newline)]
++ new_areas_cats = [self._getLineAreasCategories(newline)]
+
+ if newline > 0 and self._settings['breakLines']:
+ self._breakLineAtIntersection(newline, None)
+@@ -703,7 +959,13 @@
+ if newline > 0:
+ self._addChangeset()
+ self.toolbar.EnableUndo()
+-
++
++ if self.emit_signals:
++ self.lineEdited.emit(old_bboxs = old_bboxs,
++ old_areas_cats = old_areas_cats,
++ new_bboxs = new_bboxs,
++ new_areas_cats = new_areas_cats)
++
+ return newline
+
+ def FlipLine(self):
+@@ -1514,6 +1776,16 @@
+ return 0
+
+ poList = self._display.GetSelectedIList()
++
++ if self.emit_signals:
++ cList = poList.contents
++
++ old_bboxs = [self._getBbox(cList.value[0])]
++ old_areas_cats = [self._getLineAreasCategories(cList.value[0])]
++
++ Vect_set_updated(self.poMapInfo, 1)
++ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
++
+ Vect_reset_line(self.poPoints)
+ Vect_append_point(self.poPoints, coords[0], coords[1], 0.0)
+
+@@ -1525,15 +1797,35 @@
+ else:
+ ret = Vedit_remove_vertex(self.poMapInfo, poList,
+ self.poPoints, thresh)
++
+ Vect_destroy_list(poList)
++
++ if ret > 0 and self.emit_signals:
++ new_bboxs = []
++ new_areas_cats = []
++
++ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
++ for i in range(n_up_lines_old, n_up_lines):
++ new_id = Vect_get_updated_line(self.poMapInfo, i)
++ new_areas_cats.append(self._getLineAreasCategories(new_id))
++ new_bboxs.append(self._getBbox(new_id))
+
+ if not add and ret > 0 and self._settings['breakLines']:
+ self._breakLineAtIntersection(Vect_get_num_lines(self.poMapInfo),
+ None)
+-
++
+ if ret > 0:
+ self._addChangeset()
+-
++
++ if ret > 0 and self.emit_signals:
++ if add:
++ self.vertexAdded.emit(old_bboxs = old_bboxs, new_bboxs = new_bboxs)
++ else:
++ self.vertexRemoved.emit(old_bboxs = old_bboxs,
++ new_bboxs = new_bboxs,
++ old_areas_cats = old_areas_cats,
++ new_areas_cats = new_areas_cats)
++
+ return 1
+
+ def GetLineCats(self, line):
+Index: gui/wxpython/vdigit/toolbars.py
+===================================================================
+--- gui/wxpython/vdigit/toolbars.py (revision 57747)
++++ gui/wxpython/vdigit/toolbars.py (working copy)
+@@ -17,6 +17,7 @@
+ import wx
+
+ from grass.script import core as grass
++from grass.pydispatch.signal import Signal
+
+ from gui_core.toolbars import BaseToolbar, BaseIcons
+ from gui_core.dialogs import CreateNewVector
+@@ -42,6 +43,8 @@
+ self.digit = None
+ self._giface = giface
+
++ self.editingStarted = Signal("VDigitToolbar.editingStarted")
++
+ # currently selected map layer for editing (reference to MapLayer instance)
+ self.mapLayer = None
+ # list of vector layers from Layer Manager (only in the current mapset)
+@@ -860,6 +863,7 @@
+ alpha = int(opacity * 255)
+ self.digit.GetDisplay().UpdateSettings(alpha = alpha)
+
++ self.editingStarted.emit(vectMap = mapLayer.GetName(), digit = self.digit)
+ return True
+
+ def StopEditing(self):
Index: gui/wxpython/vnet/toolbars.py
===================================================================
---- gui/wxpython/vnet/toolbars.py (revision 57734)
+--- gui/wxpython/vnet/toolbars.py (revision 57747)
+++ gui/wxpython/vnet/toolbars.py (working copy)
@@ -19,9 +19,9 @@
@@ -123,7 +1973,7 @@
class PointListToolbar(BaseToolbar):
Index: gui/wxpython/vnet/dialogs.py
===================================================================
---- gui/wxpython/vnet/dialogs.py (revision 57734)
+--- gui/wxpython/vnet/dialogs.py (revision 57747)
+++ gui/wxpython/vnet/dialogs.py (working copy)
@@ -1218,7 +1218,7 @@
pos = (row, 1))
@@ -136,7 +1986,7 @@
styleBoxSizer.Add(item = gridSizer, flag = wx.EXPAND)
Index: gui/wxpython/Makefile
===================================================================
---- gui/wxpython/Makefile (revision 57734)
+--- gui/wxpython/Makefile (revision 57747)
+++ gui/wxpython/Makefile (working copy)
@@ -13,7 +13,7 @@
$(wildcard animation/* core/*.py dbmgr/* gcp/*.py gmodeler/* \
@@ -158,11 +2008,75 @@
DSTDIRS := $(patsubst %,$(ETCDIR)/%,icons scripts xml)
default: $(DSTFILES)
+Index: gui/wxpython/mapdisp/frame.py
+===================================================================
+--- gui/wxpython/mapdisp/frame.py (revision 57747)
++++ gui/wxpython/mapdisp/frame.py (working copy)
+@@ -231,6 +231,7 @@
+ #
+ self.dialogs = {}
+ self.dialogs['attributes'] = None
++ self.dialogs['scatt_plot'] = None
+ self.dialogs['category'] = None
+ self.dialogs['vnet'] = None
+ self.dialogs['query'] = None
+@@ -1199,6 +1200,19 @@
+ """!Returns toolbar with zooming tools"""
+ return self.toolbars['map']
+
++ def OnIScatt(self, event):
++ """!Init interactive scatterplot tools
++ """
++ if self.dialogs['scatt_plot']:
++ self.dialogs['scatt_plot'].Raise()
++ return
++
++ from scatt_plot.frame import IScattDialog
++ self.dialogs['scatt_plot'] = IScattDialog(parent=self, giface=self._giface)
++
++ self.dialogs['scatt_plot'].CenterOnScreen()
++ self.dialogs['scatt_plot'].Show()
++
+ def OnVNet(self, event):
+ """!Dialog for v.net* modules
+ """
+Index: gui/wxpython/mapdisp/toolbars.py
+===================================================================
+--- gui/wxpython/mapdisp/toolbars.py (revision 57747)
++++ gui/wxpython/mapdisp/toolbars.py (working copy)
+@@ -49,6 +49,8 @@
+ label = _('Create histogram of raster map')),
+ 'vnet' : MetaIcon(img = 'vector-tools',
+ label = _('Vector network analysis tool')),
++ 'interact_scatter' : MetaIcon(img = 'layer-raster-profile',
++ label = _("Interactive scatter plot tool")),
+ }
+
+ NvizIcons = {
+@@ -239,7 +241,9 @@
+ (MapIcons["scatter"], self.parent.OnScatterplot),
+ (MapIcons["histogram"], self.parent.OnHistogramPyPlot),
+ (BaseIcons["histogramD"], self.parent.OnHistogram),
+- (MapIcons["vnet"], self.parent.OnVNet)))
++ (MapIcons["vnet"], self.parent.OnVNet),
++ (MapIcons["interact_scatter"],
++ self.parent.OnIScatt)))
+
+ def OnDecoration(self, event):
+ """!Decorations overlay menu
Index: gui/wxpython/iclass/dialogs.py
===================================================================
---- gui/wxpython/iclass/dialogs.py (revision 57734)
+--- gui/wxpython/iclass/dialogs.py (revision 57747)
+++ gui/wxpython/iclass/dialogs.py (working copy)
-@@ -403,8 +403,23 @@
+@@ -337,7 +337,6 @@
+ def OnClose(self, event):
+ self.catList.DeselectAll()
+
+- self.catList.UpdateChoice()
+ self.Hide()
+ #if not isinstance(event, wx.CloseEvent):
+ #self.Destroy()
+@@ -403,12 +402,26 @@
except UnicodeEncodeError:
GMessage(parent = self, message = _("Please use only ASCII characters."))
return
@@ -186,28 +2100,52 @@
cat = self.stats_data.GetCategories()[row]
self.stats_data.GetStatistics(cat).SetStatistics(stats = {attr : text})
-@@ -469,13 +484,19 @@
- toolbar.SetCategories(catNames = catNames, catIdx = cats)
- if name in catNames:
- toolbar.choice.SetStringSelection(name)
-+ cat = toolbar.GetSelectedCategoryIdx()
- elif catNames:
- toolbar.choice.SetSelection(0)
--
-+ cat = toolbar.GetSelectedCategoryIdx()
-+ else:
-+ cat = None
-+
- if toolbar.choice.IsEmpty():
- toolbar.EnableControls(False)
- else:
- toolbar.EnableControls(True)
-+
-+ self.mapWindow.CategoryChanged(cat)
- # don't forget to update maps, histo, ...
+- self.UpdateChoice()
+ toolbar = self.mapWindow.toolbars['iClass']
+ toolbar.choice.SetSelection(row)
+ self.Select(row)
+@@ -431,7 +444,6 @@
+ self.stats_data.AddStatistics(cat, name, color)
+ self.SetItemCount(len(self.stats_data.GetCategories()))
+- self.UpdateChoice()
+ self.mapWindow.UpdateChangeState(changes = True)
+
+ def DeleteCategory(self):
+@@ -452,32 +464,10 @@
+
+ self.SetItemCount(len(self.stats_data.GetCategories()))
+
+- self.UpdateChoice()
+ self.mapWindow.UpdateChangeState(changes = True)
+
+ self.mapWindow.DeleteAreas(cats = del_cats)
+-
+- def UpdateChoice(self):
+- toolbar = self.mapWindow.toolbars['iClass']
+- name = toolbar.GetSelectedCategoryName()
+- catNames = []
+-
+- cats = self.stats_data.GetCategories()
+- for cat in cats:
+- stat = self.stats_data.GetStatistics(cat)
+- catNames.append(stat.name)
+- toolbar.SetCategories(catNames = catNames, catIdx = cats)
+- if name in catNames:
+- toolbar.choice.SetStringSelection(name)
+- elif catNames:
+- toolbar.choice.SetSelection(0)
+
+- if toolbar.choice.IsEmpty():
+- toolbar.EnableControls(False)
+- else:
+- toolbar.EnableControls(True)
+- # don't forget to update maps, histo, ...
+-
def GetSelectedIndices(self, state = wx.LIST_STATE_SELECTED):
-@@ -560,6 +581,29 @@
+ indices = []
+ lastFound = -1
+@@ -560,6 +550,29 @@
def OnGetItemAttr(self, item):
return None
@@ -239,8 +2177,17 @@
file = None, title = _("Save signature file"), id = wx.ID_ANY,
Index: gui/wxpython/iclass/toolbars.py
===================================================================
---- gui/wxpython/iclass/toolbars.py (revision 57734)
+--- gui/wxpython/iclass/toolbars.py (revision 57747)
+++ gui/wxpython/iclass/toolbars.py (working copy)
+@@ -23,7 +23,7 @@
+ from core.utils import _
+ from gui_core.toolbars import BaseToolbar, BaseIcons
+ from icons.icon import MetaIcon
+-from iclass.dialogs import IClassMapDialog
++from iclass.dialogs import IClassMapDialog, ContrastColor
+ from gui_core.forms import GUI
+
+ import grass.script as grass
@@ -46,9 +46,7 @@
'importAreas' : MetaIcon(img = 'layer-import',
label = _('Import training areas from vector map')),
@@ -252,7 +2199,7 @@
}
class IClassMapToolbar(BaseToolbar):
-@@ -117,10 +115,7 @@
+@@ -117,17 +115,16 @@
("zoomBack", icons["zoomBack"],
self.parent.OnZoomBack),
("zoomToMap", icons["zoomExtent"],
@@ -264,9 +2211,100 @@
))
class IClassToolbar(BaseToolbar):
"""!IClass toolbar
+ """
+- def __init__(self, parent):
++ def __init__(self, parent, stats_data):
+ """!IClass toolbar constructor
+ """
++ self.stats_data = stats_data
++
+ BaseToolbar.__init__(self, parent)
+ self.InitToolbar(self._toolbarData())
+
+@@ -148,7 +145,12 @@
+
+ self.combo.Bind(wx.EVT_COMBOBOX, self.OnStdChangeSelection)
+ self.combo.Bind(wx.EVT_TEXT_ENTER, self.OnStdChangeText)
+-
++
++ self.stats_data.statisticsAdded.connect(self.Update)
++ self.stats_data.statisticsDeleted.connect(self.Update)
++ self.stats_data.allStatisticsDeleted.connect(self.Update)
++ self.stats_data.statisticsSet.connect(self.Update)
++
+ # realize the toolbar
+ self.Realize()
+
+@@ -171,13 +173,30 @@
+ ("sigFile", icons['sigFile'],
+ self.parent.OnSaveSigFile),
+ ))
+-
++
++ def OnMotion(self, event):
++ print self.choice.GetStringSelection()
++
+ def OnSelectCategory(self, event):
+ idx = self.choice.GetSelection()
+ cat = self.choice.GetClientData(idx)
+-
++
++ self._updateColor(cat)
+ self.parent.CategoryChanged(currentCat = cat)
+
++ def _updateColor(self, cat):
++
++ if cat:
++ stat = self.stats_data.GetStatistics(cat)
++ back_c = wx.Colour(*map(int, stat.color.split(':')))
++ text_c = wx.Colour(*ContrastColor(back_c))
++ else:
++ back_c = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
++ text_c = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BTNTEXT)
++
++ self.choice.SetForegroundColour(text_c)
++ self.choice.SetBackgroundColour(back_c)
++
+ def SetCategories(self, catNames, catIdx):
+ self.choice.Clear()
+ for name, idx in zip(catNames, catIdx):
+@@ -231,6 +250,33 @@
+ def EnableControls(self, enable = True):
+ self.combo.Enable(enable)
+ self.choice.Enable(enable)
++
++ def Update(self, *args, **kwargs):
++ name = self.GetSelectedCategoryName()
++ catNames = []
++
++ cats = self.stats_data.GetCategories()
++ for cat in cats:
++ stat = self.stats_data.GetStatistics(cat)
++ catNames.append(stat.name)
++ self.SetCategories(catNames = catNames, catIdx = cats)
++ if name in catNames:
++ self.choice.SetStringSelection(name)
++ cat = self.GetSelectedCategoryIdx()
++ elif catNames:
++ self.choice.SetSelection(0)
++ cat = self.GetSelectedCategoryIdx()
++ else:
++ cat = None
++
++ if self.choice.IsEmpty():
++ self.EnableControls(False)
++ else:
++ self.EnableControls(True)
++
++ self._updateColor(cat)
++ self.parent.CategoryChanged(cat)
++ # don't forget to update maps, histo, ...
+
+ class IClassMapManagerToolbar(BaseToolbar):
+ """!IClass toolbar
Index: gui/wxpython/iclass/frame.py
===================================================================
---- gui/wxpython/iclass/frame.py (revision 57734)
+--- gui/wxpython/iclass/frame.py (revision 57747)
+++ gui/wxpython/iclass/frame.py (working copy)
@@ -64,6 +64,8 @@
IClassExportAreasDialog, IClassMapDialog
@@ -277,7 +2315,7 @@
class IClassMapFrame(DoubleMapFrame):
"""! wxIClass main frame
-@@ -114,6 +116,10 @@
+@@ -114,6 +116,12 @@
lambda:
self.statusbarManager.statusbarItems['coordinates'].SetAdditionalInfo(None))
self.SetSize(size)
@@ -285,9 +2323,22 @@
+ self.groupSet = Signal("IClassMapFrame.groupSet")
+ self.categoryChanged = Signal('IClassMapFrame.categoryChanged')
+
++ self.InitStatistics()
++
#
# Add toolbars
#
+@@ -162,9 +170,7 @@
+ Map = self.GetFirstMap())
+ self.previewMapManager = MapManager(self, mapWindow = self.GetSecondWindow(),
+ Map = self.GetSecondMap())
+-
+- self.InitStatistics()
+-
++
+ self.changes = False
+ self.exportVector = None
+
@@ -177,7 +183,7 @@
self.dialogs['category'] = None
@@ -306,6 +2357,15 @@
def RemoveTempVector(self):
"""!Removes temporary vector map with training areas"""
ret = RunCommand(prog = 'g.remove',
+@@ -282,7 +288,7 @@
+ BestSize((self.toolbars[name].GetBestSize())))
+
+ if name == "iClass":
+- self.toolbars[name] = IClassToolbar(self)
++ self.toolbars[name] = IClassToolbar(self, stats_data=self.stats_data)
+
+ self._mgr.AddPane(self.toolbars[name],
+ wx.aui.AuiPaneInfo().
@@ -334,11 +340,12 @@
self._addPaneMapWindow(name = 'preview')
self._addPaneToolbar(name = 'iClassTrainingMapManager')
@@ -488,7 +2548,7 @@
import core.render as render
Index: gui/wxpython/iclass/plots.py
===================================================================
---- gui/wxpython/iclass/plots.py (revision 57734)
+--- gui/wxpython/iclass/plots.py (revision 57747)
+++ gui/wxpython/iclass/plots.py (working copy)
@@ -19,6 +19,7 @@
import wx.lib.plot as plot
@@ -635,11 +2695,976 @@
def DrawCoincidencePlots(self):
"""!Draw coincidence plots"""
for bandIdx in range(len(self.bandList)):
+Index: gui/wxpython/scatt_plot/__init__.py
+===================================================================
+--- gui/wxpython/scatt_plot/__init__.py (revision 0)
++++ gui/wxpython/scatt_plot/__init__.py (working copy)
+@@ -0,0 +1,11 @@
++all = [
++ 'dialogs',
++ 'controllers',
++ 'frame',
++ 'gthreading',
++ 'plots',
++ 'scatt_core',
++ 'toolbars',
++ 'scatt_core',
++ 'core_c',
++ ]
+Index: gui/wxpython/scatt_plot/plots.py
+===================================================================
+--- gui/wxpython/scatt_plot/plots.py (revision 0)
++++ gui/wxpython/scatt_plot/plots.py (working copy)
+@@ -0,0 +1,943 @@
++"""!
++ at package scatt_plot.dialogs
++
++ at brief Ploting widgets.
++
++Classes:
++
++(C) 2013 by the GRASS Development Team
++
++This program is free software under the GNU General Public License
++(>=v2). Read the file COPYING that comes with GRASS for details.
++
++ at author Stepan Turek <stepan.turek seznam.cz> (mentor: Martin Landa)
++"""
++import wx
++import numpy as np
++from math import ceil
++#TODO testing
++import time
++from multiprocessing import Process, Queue
++
++from copy import deepcopy
++from scatt_plot.core_c import MergeArrays, ApplyColormap
++from core.settings import UserSettings
++
++try:
++ import matplotlib
++ matplotlib.use('WXAgg')
++ from matplotlib.figure import Figure
++ from matplotlib.backends.backend_wxagg import \
++ FigureCanvasWxAgg as FigCanvas
++ from matplotlib.lines import Line2D
++ from matplotlib.artist import Artist
++ from matplotlib.mlab import dist_point_to_segment
++ from matplotlib.patches import Polygon, Ellipse, Rectangle
++ import matplotlib.image as mi
++ import matplotlib.colors as mcolors
++ import matplotlib.cbook as cbook
++except ImportError as e:
++ raise ImportError(_("Unable to import matplotlib (try to install it).\n%s") % e)
++
++import grass.script as grass
++from grass.pydispatch.signal import Signal
++
++class ScatterPlotWidget(wx.Panel):
++ def __init__(self, parent, scatt_id, scatt_mgr, transpose,
++ id = wx.ID_ANY):
++
++ wx.Panel.__init__(self, parent, id)
++
++ self.parent = parent
++ self.full_extend = None
++ self.mode = None
++
++ self._createWidgets()
++ self._doLayout()
++ self.scatt_id = scatt_id
++ self.scatt_mgr = scatt_mgr
++
++ self.cidpress = None
++ self.cidrelease = None
++
++ self.transpose = transpose
++
++ self.inverse = False
++
++ self.SetSize((200, 100))
++ self.Layout()
++
++ self.base_scale = 1.2
++ self.Bind(wx.EVT_CLOSE,lambda event : self.CleanUp())
++
++ self.plotClosed = Signal("ScatterPlotWidget.plotClosed")
++ self.cursorMove = Signal("ScatterPlotWidget.cursorMove")
++
++ self.contex_menu = ScatterPlotContextMenu(plot = self)
++
++ self.ciddscroll = None
++
++ self.canvas.mpl_connect('motion_notify_event', self.Motion)
++ self.canvas.mpl_connect('button_press_event', self.OnPress)
++ self.canvas.mpl_connect('button_release_event', self.OnRelease)
++ self.canvas.mpl_connect('draw_event', self.draw_callback)
++
++ def draw_callback(self, event):
++ self.polygon_drawer.draw_callback(event)
++ self.axes.draw_artist(self.zoom_rect)
++
++ def _createWidgets(self):
++
++ # Create the mpl Figure and FigCanvas objects.
++ # 5x4 inches, 100 dots-per-inch
++ #
++ self.dpi = 100
++ self.fig = Figure((1.0, 1.0), dpi=self.dpi)
++ self.fig.autolayout = True
++
++ self.canvas = FigCanvas(self, -1, self.fig)
++
++ self.axes = self.fig.add_axes([0.0,0.0,1,1])
++
++ pol = Polygon(list(zip([0], [0])), animated=True)
++ self.axes.add_patch(pol)
++ self.polygon_drawer = PolygonDrawer(self.axes, pol = pol, empty_pol = True)
++
++ self.zoom_wheel_coords = None
++ self.zoom_rect_coords = None
++ self.zoom_rect = Polygon(list(zip([0], [0])), facecolor = 'none')
++ self.zoom_rect.set_visible(False)
++ self.axes.add_patch(self.zoom_rect)
++
++ def ZoomToExtend(self):
++ if self.full_extend:
++ self.axes.axis(self.full_extend)
++ self.canvas.draw()
++
++ def SetMode(self, mode):
++ self._deactivateMode()
++ if mode == 'zoom':
++ self.ciddscroll = self.canvas.mpl_connect('scroll_event', self.ZoomWheel)
++ self.mode = 'zoom'
++ elif mode == 'zoom_extend':
++ self.mode = 'zoom_extend'
++ elif mode == 'pan':
++ self.mode = 'pan'
++ elif mode:
++ self.polygon_drawer.SetMode(mode)
++
++ def SetSelectionPolygonMode(self, activate):
++ self.polygon_drawer.SetSelectionPolygonMode(activate)
++
++ def _deactivateMode(self):
++ self.mode = None
++ self.polygon_drawer.SetMode(None)
++
++ if self.ciddscroll:
++ self.canvas.mpl_disconnect(self.ciddscroll)
++
++ self.zoom_rect.set_visible(False)
++ self._stopCategoryEdit()
++
++ def GetCoords(self):
++
++ coords = self.polygon_drawer.GetCoords()
++ if coords is None:
++ return
++
++ if self.transpose:
++ for c in coords:
++ tmp = c[0]
++ c[0] = c[1]
++ c[1] = tmp
++
++ return coords
++
++ def SetEmpty(self):
++ return self.polygon_drawer.SetEmpty()
++
++ def OnRelease(self, event):
++ if not self.mode == "zoom": return
++ self.zoom_rect.set_visible(False)
++ self.ZoomRectangle(event)
++ self.canvas.draw()
++
++ def OnPress(self, event):
++ 'on button press we will see if the mouse is over us and store some data'
++ if not event.inaxes:
++ return
++ if self.mode == "zoom_extend":
++ self.ZoomToExtend()
++
++ if event.xdata and event.ydata:
++ self.zoom_wheel_coords = { 'x' : event.xdata, 'y' : event.ydata}
++ self.zoom_rect_coords = { 'x' : event.xdata, 'y' : event.ydata}
++ else:
++ self.zoom_wheel_coords = None
++ self.zoom_rect_coords = None
++
++ def _stopCategoryEdit(self):
++ 'disconnect all the stored connection ids'
++
++ if self.cidpress:
++ self.canvas.mpl_disconnect(self.cidpress)
++ if self.cidrelease:
++ self.canvas.mpl_disconnect(self.cidrelease)
++ #self.canvas.mpl_disconnect(self.cidmotion)
++
++ def _doLayout(self):
++
++ self.main_sizer = wx.BoxSizer(wx.VERTICAL)
++ self.main_sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
++ self.SetSizer(self.main_sizer)
++ self.main_sizer.Fit(self)
++
++ def Plot(self, cats_order, scatts, ellipses, styles):
++ """ Redraws the figure
++ """
++
++ callafter_list = []
++
++ if self.full_extend:
++ cx = self.axes.get_xlim()
++ cy = self.axes.get_ylim()
++ c = cx + cy
++ else:
++ c = None
++
++ #q = Queue()
++ #p = Process(target=MergeImg, args=(cats_order, scatts, styles, self.transpose, q))
++ #p.start()
++ #merged_img, self.full_extend = q.get()
++ #p.join()
++
++ merged_img, self.full_extend = MergeImg(cats_order, scatts, styles, None)
++ self.axes.clear()
++ self.axes.axis('equal')
++
++ if self.transpose:
++ merged_img = np.transpose(merged_img, (1, 0, 2))
++
++ img = imshow(self.axes, merged_img,
++ extent= [int(ceil(x)) for x in self.full_extend],
++ origin='lower',
++ interpolation='nearest',
++ aspect="equal")
++
++ callafter_list.append([self.axes.draw_artist, [img]])
++ callafter_list.append([grass.try_remove, [merged_img.filename]])
++
++ for cat_id in cats_order:
++ if cat_id == 0:
++ continue
++ if not ellipses.has_key(cat_id):
++ continue
++
++ e = ellipses[cat_id]
++ if not e:
++ continue
++
++ colors = styles[cat_id]['color'].split(":")
++ if self.transpose:
++ e['theta'] = 360 - e['theta'] + 90
++ if e['theta'] >= 360:
++ e['theta'] = abs(360 - e['theta'])
++
++ e['pos'] = [e['pos'][1], e['pos'][0]]
++
++ ellip = Ellipse(xy=e['pos'],
++ width=e['width'],
++ height=e['height'],
++ angle=e['theta'],
++ edgecolor="w",
++ linewidth=1.5,
++ facecolor='None')
++ self.axes.add_artist(ellip)
++ callafter_list.append([self.axes.draw_artist, [ellip]])
++
++ color = map(lambda v : int(v)/255.0, styles[cat_id]['color'].split(":"))
++
++ ellip = Ellipse(xy=e['pos'],
++ width=e['width'],
++ height=e['height'],
++ angle=e['theta'],
++ edgecolor=color,
++ linewidth=1,
++ facecolor='None')
++
++ self.axes.add_artist(ellip)
++ callafter_list.append([self.axes.draw_artist, [ellip]])
++
++ center = Line2D([e['pos'][0]], [e['pos'][1]],
++ marker='x',
++ markeredgecolor='w',
++ #markerfacecolor=color,
++ markersize=2)
++ self.axes.add_artist(center)
++ callafter_list.append([self.axes.draw_artist, [center]])
++
++ callafter_list.append([self.fig.canvas.blit, []])
++
++ if c:
++ self.axes.axis(c)
++ wx.CallAfter(lambda : self.CallAfter(callafter_list))
++
++ def CallAfter(self, funcs_list):
++ while funcs_list:
++ fcn, args = funcs_list.pop(0)
++ fcn(*args)
++
++ self.canvas.draw()
++
++ def CleanUp(self):
++ self.plotClosed.emit(scatt_id = self.scatt_id)
++ self.Destroy()
++
++ def ZoomWheel(self, event):
++ # get the current x and y limits
++ if not event.inaxes:
++ return
++ # tcaswell
++ # http://stackoverflow.com/questions/11551049/matplotlib-plot-zooming-with-scroll-wheel
++ cur_xlim = self.axes.get_xlim()
++ cur_ylim = self.axes.get_ylim()
++
++ xdata = event.xdata
++ ydata = event.ydata
++ if event.button == 'up':
++ scale_factor = 1/self.base_scale
++ elif event.button == 'down':
++ scale_factor = self.base_scale
++ else:
++ scale_factor = 1
++
++ extend = (xdata - (xdata - cur_xlim[0]) * scale_factor,
++ xdata + (cur_xlim[1] - xdata) * scale_factor,
++ ydata - (ydata - cur_ylim[0]) * scale_factor,
++ ydata + (cur_ylim[1] - ydata) * scale_factor)
++
++ self.axes.axis(extend)
++
++ self.canvas.draw()
++
++ def ZoomRectangle(self, event):
++ # get the current x and y limits
++ if not self.mode == "zoom": return
++ if event.inaxes is None: return
++ if event.button != 1: return
++
++ cur_xlim = self.axes.get_xlim()
++ cur_ylim = self.axes.get_ylim()
++
++ x1, y1 = event.xdata, event.ydata
++ x2 = deepcopy(self.zoom_rect_coords['x'])
++ y2 = deepcopy(self.zoom_rect_coords['y'])
++
++ if x1 == x2 or y1 == y2:
++ return
++
++ self.axes.axis((x1, x2, y1, y2))
++ #self.axes.set_xlim(x1, x2)#, auto = True)
++ #self.axes.set_ylim(y1, y2)#, auto = True)
++ self.canvas.draw()
++
++ def Motion(self, event):
++ self.PanMotion(event)
++ self.ZoomRectMotion(event)
++
++ if event.inaxes is None:
++ return
++
++ self.cursorMove.emit(x=event.xdata, y=event.ydata)
++
++ def PanMotion(self, event):
++ 'on mouse movement'
++ if not self.mode == "pan":
++ return
++ if event.inaxes is None:
++ return
++ if event.button != 1:
++ return
++
++ cur_xlim = self.axes.get_xlim()
++ cur_ylim = self.axes.get_ylim()
++
++ x,y = event.xdata, event.ydata
++
++ mx = (x - self.zoom_wheel_coords['x']) * 0.6
++ my = (y - self.zoom_wheel_coords['y']) * 0.6
++
++ extend = (cur_xlim[0] - mx, cur_xlim[1] - mx, cur_ylim[0] - my, cur_ylim[1] - my)
++
++ self.zoom_wheel_coords['x'] = x
++ self.zoom_wheel_coords['y'] = y
++
++ self.axes.axis(extend)
++
++ #self.canvas.copy_from_bbox(self.axes.bbox)
++ #self.canvas.restore_region(self.background)
++ self.canvas.draw()
++
++ def ZoomRectMotion(self, event):
++ if not self.mode == "zoom": return
++ if event.inaxes is None: return
++ if event.button != 1: return
++
++ x1, y1 = event.xdata, event.ydata
++ self.zoom_rect.set_visible(True)
++ x2 = self.zoom_rect_coords['x']
++ y2 = self.zoom_rect_coords['y']
++
++ self.zoom_rect.xy = ((x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1))
++
++ #self.axes.draw_artist(self.zoom_rect)
++ self.canvas.draw()
++
++class ScatterPlotContextMenu:
++ def __init__(self, plot):
++
++ self.plot = plot
++ self.canvas = plot.canvas
++ self.cidpress = self.canvas.mpl_connect(
++ 'button_press_event', self.ContexMenu)
++
++ def ContexMenu(self, event):
++ if not event.inaxes:
++ return
++
++ if event.button == 3:
++ menu = wx.Menu()
++ menu_items = [["zoom_to_extend", _("Zoom to scatter plot extend"), lambda event : self.plot.ZoomToExtend()]]
++
++ for item in menu_items:
++ item_id = wx.ID_ANY
++ menu.Append(item_id, text = item[1])
++ menu.Bind(wx.EVT_MENU, item[2], id = item_id)
++
++ wx.CallAfter(self.ShowMenu, menu)
++
++ def ShowMenu(self, menu):
++ self.plot.PopupMenu(menu)
++ menu.Destroy()
++ self.plot.ReleaseMouse()
++
++class PolygonDrawer:
++ """
++ An polygon editor.
++ """
++ def __init__(self, ax, pol, empty_pol):
++ if pol.figure is None:
++ raise RuntimeError('You must first add the polygon to a figure or canvas before defining the interactor')
++ self.ax = ax
++ self.canvas = pol.figure.canvas
++
++ self.showverts = True
++
++ self.pol = pol
++ self.empty_pol = empty_pol
++
++ x, y = zip(*self.pol.xy)
++
++ style = self._getPolygonStyle()
++
++ self.line = Line2D(x, y, marker='o', markerfacecolor='r', animated=True)
++ self.ax.add_line(self.line)
++ #self._update_line(pol)
++
++ cid = self.pol.add_callback(self.poly_changed)
++ self.moving_ver_idx = None # the active vert
++
++ self.mode = None
++
++ if self.empty_pol:
++ self._show(False)
++
++ #self.canvas.mpl_connect('draw_event', self.draw_callback)
++ self.canvas.mpl_connect('button_press_event', self.OnButtonPressed)
++ self.canvas.mpl_connect('button_release_event', self.button_release_callback)
++ self.canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
++
++ self.it = 0
++
++ def _getPolygonStyle(self):
++ style = {}
++ style['sel_pol'] = UserSettings.Get(group='scatt',
++ key='selection',
++ subkey='sel_pol')
++ style['sel_pol_vertex'] = UserSettings.Get(group='scatt',
++ key='selection',
++ subkey='sel_pol_vertex')
++
++ style['sel_pol'] = [i / 255.0 for i in style['sel_pol']]
++ style['sel_pol_vertex'] = [i / 255.0 for i in style['sel_pol_vertex']]
++
++ return style
++
++ def _getSnapTresh(self):
++ return UserSettings.Get(group='scatt',
++ key='selection',
++ subkey='snap_tresh')
++
++ def SetMode(self, mode):
++ self.mode = mode
++
++ def SetSelectionPolygonMode(self, activate):
++
++ self.Show(activate)
++ if not activate and self.mode:
++ self.SetMode(None)
++
++ def Show(self, show):
++ if show:
++ if not self.empty_pol:
++ self._show(True)
++ else:
++ self._show(False)
++
++ def GetCoords(self):
++ if self.empty_pol:
++ return None
++
++ coords = deepcopy(self.pol.xy)
++ return coords
++
++ def SetEmpty(self):
++ self._setEmptyPol(True)
++
++ def _setEmptyPol(self, empty_pol):
++ self.empty_pol = empty_pol
++ self._show(not empty_pol)
++
++ def _show(self, show):
++
++ self.show = show
++
++ self.line.set_visible(self.show)
++ self.pol.set_visible(self.show)
++
++ self.Redraw()
++
++ def Redraw(self):
++ if self.show:
++ self.ax.draw_artist(self.pol)
++ self.ax.draw_artist(self.line)
++ self.canvas.blit(self.ax.bbox)
++ self.canvas.draw()
++
++ def draw_callback(self, event):
++
++ style=self._getPolygonStyle()
++ self.pol.set_facecolor(style['sel_pol'])
++ self.line.set_markerfacecolor(style['sel_pol_vertex'])
++
++ self.background = self.canvas.copy_from_bbox(self.ax.bbox)
++ self.ax.draw_artist(self.pol)
++ self.ax.draw_artist(self.line)
++
++ def poly_changed(self, pol):
++ 'this method is called whenever the polygon object is called'
++ # only copy the artist props to the line (except visibility)
++ vis = self.line.get_visible()
++ Artist.update_from(self.line, pol)
++ self.line.set_visible(vis) # don't use the pol visibility state
++
++ def get_ind_under_point(self, event):
++ 'get the index of the vertex under point if within treshold'
++
++ # display coords
++ xy = np.asarray(self.pol.xy)
++ xyt = self.pol.get_transform().transform(xy)
++ xt, yt = xyt[:, 0], xyt[:, 1]
++ d = np.sqrt((xt-event.x)**2 + (yt-event.y)**2)
++ indseq = np.nonzero(np.equal(d, np.amin(d)))[0]
++ ind = indseq[0]
++
++ if d[ind]>=self._getSnapTresh():
++ ind = None
++
++ return ind
++
++ def OnButtonPressed(self, event):
++ if not event.inaxes:
++ return
++
++ if event.button in [2, 3]:
++ return
++
++ if self.mode == "delete_vertex":
++ self._deleteVertex(event)
++ elif self.mode == "add_boundary_vertex":
++ self._addVertexOnBoundary(event)
++ elif self.mode == "add_vertex":
++ self._addVertex(event)
++ elif self.mode == "remove_polygon":
++ self.SetEmpty()
++ self.moving_ver_idx = self.get_ind_under_point(event)
++
++ def button_release_callback(self, event):
++ 'whenever a mouse button is released'
++ if not self.showverts: return
++ if event.button != 1: return
++ self.moving_ver_idx = None
++
++ def ShowVertices(self, show):
++ self.showverts = show
++ self.line.set_visible(self.showverts)
++ if not self.showverts: self.moving_ver_idx = None
++
++ def _deleteVertex(self, event):
++ ind = self.get_ind_under_point(event)
++
++ if ind is None or self.empty_pol:
++ return
++
++ if len(self.pol.xy) <= 2:
++ self.empty_pol = True
++ self._show(False)
++ return
++
++ coords = []
++ for i,tup in enumerate(self.pol.xy):
++ if i == ind:
++ continue
++ elif i == 0 and ind == len(self.pol.xy) - 1:
++ continue
++ elif i == len(self.pol.xy) - 1 and ind == 0:
++ continue
++
++ coords.append(tup)
++
++ self.pol.xy = coords
++ self.line.set_data(zip(*self.pol.xy))
++
++ self.Redraw()
++
++ def _addVertexOnBoundary(self, event):
++ if self.empty_pol:
++ return
++
++ xys = self.pol.get_transform().transform(self.pol.xy)
++ p = event.x, event.y # display coords
++ for i in range(len(xys)-1):
++ s0 = xys[i]
++ s1 = xys[i+1]
++ d = dist_point_to_segment(p, s0, s1)
++
++ if d<=self._getSnapTresh():
++ self.pol.xy = np.array(
++ list(self.pol.xy[:i + 1]) +
++ [(event.xdata, event.ydata)] +
++ list(self.pol.xy[i + 1:]))
++ self.line.set_data(zip(*self.pol.xy))
++ break
++
++ self.Redraw()
++
++ def _addVertex(self, event):
++
++ if self.empty_pol:
++ pt = (event.xdata, event.ydata)
++ self.pol.xy = np.array([pt, pt])
++ self._show(True)
++ self.empty_pol = False
++ else:
++ self.pol.xy = np.array(
++ [(event.xdata, event.ydata)] +
++ list(self.pol.xy[1:]) +
++ [(event.xdata, event.ydata)])
++
++ self.line.set_data(zip(*self.pol.xy))
++
++ self.Redraw()
++
++ def motion_notify_callback(self, event):
++ 'on mouse movement'
++ if not self.mode == "move_vertex": return
++ if not self.showverts: return
++ if self.empty_pol: return
++ if self.moving_ver_idx is None: return
++ if event.inaxes is None: return
++ if event.button != 1: return
++
++ self.it += 1
++
++ x,y = event.xdata, event.ydata
++
++ self.pol.xy[self.moving_ver_idx] = x,y
++ if self.moving_ver_idx == 0:
++ self.pol.xy[len(self.pol.xy) - 1] = x,y
++ elif self.moving_ver_idx == len(self.pol.xy) - 1:
++ self.pol.xy[0] = x,y
++
++ self.line.set_data(zip(*self.pol.xy))
++
++ self.canvas.restore_region(self.background)
++
++ self.Redraw()
++
++class ModestImage(mi.AxesImage):
++ """
++ Computationally modest image class.
++
++ ModestImage is an extension of the Matplotlib AxesImage class
++ better suited for the interactive display of larger images. Before
++ drawing, ModestImage resamples the data array based on the screen
++ resolution and view window. This has very little affect on the
++ appearance of the image, but can substantially cut down on
++ computation since calculations of unresolved or clipped pixels
++ are skipped.
++
++ The interface of ModestImage is the same as AxesImage. However, it
++ does not currently support setting the 'extent' property. There
++ may also be weird coordinate warping operations for images that
++ I'm not aware of. Don't expect those to work either.
++
++ Author: Chris Beaumont <beaumont at hawaii.edu>
++ """
++ def __init__(self, minx=0.0, miny=0.0, *args, **kwargs):
++ if 'extent' in kwargs and kwargs['extent'] is not None:
++ raise NotImplementedError("ModestImage does not support extents")
++
++ self._full_res = None
++ self._sx, self._sy = None, None
++ self._bounds = (None, None, None, None)
++ self.minx = minx
++ self.miny = miny
++
++ super(ModestImage, self).__init__(*args, **kwargs)
++
++ def set_data(self, A):
++ """
++ Set the image array
++
++ ACCEPTS: numpy/PIL Image A
++ """
++ self._full_res = A
++ self._A = A
++
++ if self._A.dtype != np.uint8 and not np.can_cast(self._A.dtype,
++ np.float):
++ raise TypeError("Image data can not convert to float")
++
++ if (self._A.ndim not in (2, 3) or
++ (self._A.ndim == 3 and self._A.shape[-1] not in (3, 4))):
++ raise TypeError("Invalid dimensions for image data")
++
++ self._imcache =None
++ self._rgbacache = None
++ self._oldxslice = None
++ self._oldyslice = None
++ self._sx, self._sy = None, None
++
++ def get_array(self):
++ """Override to return the full-resolution array"""
++ return self._full_res
++
++ def _scale_to_res(self):
++ """ Change self._A and _extent to render an image whose
++ resolution is matched to the eventual rendering."""
++
++ ax = self.axes
++ ext = ax.transAxes.transform([1, 1]) - ax.transAxes.transform([0, 0])
++ xlim, ylim = ax.get_xlim(), ax.get_ylim()
++ dx, dy = xlim[1] - xlim[0], ylim[1] - ylim[0]
++
++ y0 = max(self.miny, ylim[0] - 5)
++ y1 = min(self._full_res.shape[0] + self.miny, ylim[1] + 5)
++ x0 = max(self.minx, xlim[0] - 5)
++ x1 = min(self._full_res.shape[1] + self.minx, xlim[1] + 5)
++ y0, y1, x0, x1 = map(int, [y0, y1, x0, x1])
++
++ sy = int(max(1, min((y1 - y0) / 5., np.ceil(dy / ext[1]))))
++ sx = int(max(1, min((x1 - x0) / 5., np.ceil(dx / ext[0]))))
++
++ # have we already calculated what we need?
++ if sx == self._sx and sy == self._sy and \
++ x0 == self._bounds[0] and x1 == self._bounds[1] and \
++ y0 == self._bounds[2] and y1 == self._bounds[3]:
++ return
++
++ self._A = self._full_res[y0 - self.miny:y1 - self.miny:sy,
++ x0 - self.minx:x1 - self.minx:sx]
++
++ x1 = x0 + self._A.shape[1] * sx
++ y1 = y0 + self._A.shape[0] * sy
++
++ self.set_extent([x0 - .5, x1 - .5, y0 - .5, y1 - .5])
++ self._sx = sx
++ self._sy = sy
++ self._bounds = (x0, x1, y0, y1)
++ self.changed()
++
++ def draw(self, renderer, *args, **kwargs):
++ self._scale_to_res()
++ super(ModestImage, self).draw(renderer, *args, **kwargs)
++
++def imshow(axes, X, cmap=None, norm=None, aspect=None,
++ interpolation=None, alpha=None, vmin=None, vmax=None,
++ origin=None, extent=None, shape=None, filternorm=1,
++ filterrad=4.0, imlim=None, resample=None, url=None, **kwargs):
++ """Similar to matplotlib's imshow command, but produces a ModestImage
++
++ Unlike matplotlib version, must explicitly specify axes
++ Author: Chris Beaumont <beaumont at hawaii.edu>
++ """
++
++ if not axes._hold:
++ axes.cla()
++ if norm is not None:
++ assert(isinstance(norm, mcolors.Normalize))
++ if aspect is None:
++ aspect = rcParams['image.aspect']
++ axes.set_aspect(aspect)
++
++ if extent:
++ minx=extent[0]
++ miny=extent[2]
++ else:
++ minx=0.0
++ miny=0.0
++
++ im = ModestImage(minx, miny, axes, cmap, norm, interpolation, origin, extent,
++ filternorm=filternorm,
++ filterrad=filterrad, resample=resample, **kwargs)
++
++ im.set_data(X)
++ im.set_alpha(alpha)
++ axes._set_artist_props(im)
++
++ if im.get_clip_path() is None:
++ # image does not already have clipping set, clip to axes patch
++ im.set_clip_path(axes.patch)
++
++ #if norm is None and shape is None:
++ # im.set_clim(vmin, vmax)
++ if vmin is not None or vmax is not None:
++ im.set_clim(vmin, vmax)
++ else:
++ im.autoscale_None()
++ im.set_url(url)
++
++ # update ax.dataLim, and, if autoscaling, set viewLim
++ # to tightly fit the image, regardless of dataLim.
++ im.set_extent(im.get_extent())
++
++ axes.images.append(im)
++ im._remove_method = lambda h: axes.images.remove(h)
++
++ return im
++
++def MergeImg(cats_order, scatts, styles, output_queue):
++
++ start_time = time.clock()
++ cmap_time = 0
++ merge_time = 0
++ mask_time = 0
++ norm_time = 0
++ max_time = 0
++
++ init = True
++ merge_tmp = grass.tempfile()
++ for cat_id in cats_order:
++ if not scatts.has_key(cat_id):
++ continue
++ scatt = scatts[cat_id]
++ #print "color map %d" % cat_id
++ #TODO make more general
++ if cat_id != 0 and (styles[cat_id]['opacity'] == 0.0 or \
++ not styles[cat_id]['show']):
++ continue
++ if init:
++
++ b2_i = scatt['bands_info']['b1']
++ b1_i = scatt['bands_info']['b2']
++
++ full_extend = (b1_i['min'] - 0.5, b1_i['max'] + 0.5, b2_i['min'] - 0.5, b2_i['max'] + 0.5)
++
++ if cat_id == 0:
++ cmap = matplotlib.cm.jet
++ cmap.set_bad('w',1.)
++ cmap._init()
++ cmap._lut[len(cmap._lut) - 1, -1] = 0
++ else:
++ colors = styles[cat_id]['color'].split(":")
++
++ cmap = matplotlib.cm.jet
++ cmap.set_bad('w',1.)
++ cmap._init()
++ cmap._lut[len(cmap._lut) - 1, -1] = 0
++ cmap._lut[:, 0] = int(colors[0])/255.0
++ cmap._lut[:, 1] = int(colors[1])/255.0
++ cmap._lut[:, 2] = int(colors[2])/255.0
++
++ #if init:
++ tmp = time.clock()
++
++ masked_cat = np.ma.masked_less_equal(scatt['np_vals'], 0)
++ mask_time += time.clock() - tmp
++
++ tmp = time.clock()
++ vmax = np.amax(masked_cat)
++ max_time += time.clock() - tmp
++
++ tmp = time.clock()
++ masked_cat = np.uint8(masked_cat * (255.0 / float(vmax)))
++ norm_time += time.clock() - tmp
++
++ #print masked_cat
++ #print masked_cat.shape
++ #print masked_cat.mask.dtype
++ #
++ #print "colored_cat.shape"
++ #print colored_cat.shape
++ #merged_img = np.memmap(merge_tmp, dtype='uint8',, shape=colored_cat.shape)
++ tmp = time.clock()
++ cmap = np.uint8(cmap._lut * 255)
++ sh =masked_cat.shape
++
++ colored_cat = np.zeros(dtype='uint8', shape=(sh[0], sh[1], 4))
++ ApplyColormap(masked_cat, masked_cat.mask, cmap, colored_cat)
++
++ #colored_cat = np.uint8(cmap(masked_cat) * 255)
++ cmap_time += time.clock() - tmp
++
++ del masked_cat
++ del cmap
++
++ #colored_cat[...,3] = np.choose(masked_cat.mask, (255, 0))
++
++ tmp = time.clock()
++ if init:
++ merged_img = np.memmap(merge_tmp, dtype='uint8', mode='w+', shape=colored_cat.shape)
++ merged_img[:] = colored_cat[:]
++ init = False
++ else:
++ MergeArrays(merged_img, colored_cat, styles[cat_id]['opacity'])
++
++ """
++ #c_img_a = np.memmap(grass.tempfile(), dtype="uint16", mode='w+', shape = shape)
++ c_img_a = colored_cat.astype('uint16')[:,:,3] * styles[cat_id]['opacity']
++
++ #TODO apply strides and there will be no need for loop
++ #b = as_strided(a, strides=(0, a.strides[3], a.strides[3], a.strides[3]), shape=(3, a.shape[0], a.shape[1]))
++
++ for i in range(3):
++ merged_img[:,:,i] = (merged_img[:,:,i] * (255 - c_img_a) + colored_cat[:,:,i] * c_img_a) / 255;
++ merged_img[:,:,3] = (merged_img[:,:,3] * (255 - c_img_a) + 255 * c_img_a) / 255;
++
++ del c_img_a
++ """
++ merge_time += time.clock() - tmp
++
++ del colored_cat
++
++ end_time = time.clock() - start_time
++ #print "all time:%f" % (end_time)
++ #print "cmap_time:%f" % (cmap_time / end_time * 100.0 )
++ #print "merge_time:%f" % (merge_time / end_time * 100.0 )
++ #print "mask_time:%f" % (mask_time / end_time * 100.0 )
++ #print "nax_time:%f" % (max_time / end_time * 100.0 )
++ #print "norm_time:%f" % (norm_time / end_time * 100.0 )
++
++ #output_queue.put((merged_img, full_extend))
++ return merged_img, full_extend
+\ No newline at end of file
Index: gui/wxpython/scatt_plot/controllers.py
===================================================================
--- gui/wxpython/scatt_plot/controllers.py (revision 0)
+++ gui/wxpython/scatt_plot/controllers.py (working copy)
-@@ -0,0 +1,893 @@
+@@ -0,0 +1,888 @@
+"""!
+ at package scatt_plot.controllers
+
@@ -660,11 +3685,9 @@
+#TODO just for testing
+import time
+
-+#TODO
+import wx
+
+from core.gcmd import GException, GError, GMessage, RunCommand
-+from core.gconsole import EVT_CMD_DONE
+from core.settings import UserSettings
+from scatt_plot.gthreading import gThread
+from scatt_plot.scatt_core import Core, idBandsToidScatt
@@ -674,11 +3697,10 @@
+import grass.script as grass
+from grass.pydispatch.signal import Signal
+
-+class ScattsManager(wx.EvtHandler):
++class ScattsManager:
+ def __init__(self, guiparent, giface, iclass_mapwin = None):
+ #TODO remove iclass parameter
+
-+ wx.EvtHandler.__init__(self)
+ self.giface = giface
+ self.mapDisp = giface.GetMapDisplay()
+
@@ -692,14 +3714,13 @@
+ self.show_add_scatt_plot = False
+
+ self.core = Core()
-+ self.scatts_dt, self.scatt_conds_dt = self.core.GetScattsData()
+
+ self.cats_mgr = CategoriesManager(self, self.core)
++ self.render_mgr = RenderingManager(scatt_mgr=self, cats_mgr=self.cats_mgr, core=self.core)
+
-+ self.thread = gThread(self);
++ self.thread = gThread();
+
+ self.plots = {}
-+ self.cats_to_update = []
+
+ self.plot_mode = None
+ self.pol_sel_mode = [False, None]
@@ -708,8 +3729,8 @@
+
+ self.cursorPlotMove = Signal("ScattsManager.cursorPlotMove")
+
-+ self.renderingStarted = Signal("ScattsManager.renderingStarted")
-+ self.renderingFinished = Signal("ScattsManager.renderingFinished")
++ self.renderingStarted = self.render_mgr.renderingStarted
++ self.renderingFinished = self.render_mgr.renderingFinished
+
+ self.computingStarted = Signal("ScattsManager.computingStarted")
+
@@ -720,21 +3741,8 @@
+ self.digit_conn = IMapWinDigitConnection()
+ self.iclass_conn = IMapDispConnection(scatt_mgr=self, cats_mgr=self.cats_mgr, giface=self.giface)
+
-+ self.tasks_pids = {
-+ 'add_scatt' : [],
-+ 'set_data' : -1,
-+ 'set_data_add' : -1,
-+ 'set_edit_cat_data' : -1,
-+ 'mapwin_conn' : [],
-+ 'render_plots' : -1,
-+ 'render' : [],
-+ 'export_cat_rast' : []
-+ }
-+
+ self._initSettings()
+
-+ self.Bind(EVT_CMD_DONE, self.OnThreadDone)
-+
+ self.modeSet = Signal("ScattsManager.mondeSet")
+
+ def CleanUp(self):
@@ -743,7 +3751,8 @@
+
+ self.cats_mgr.CleanUp()
+ for scatt_id, scatt in self.plots.items():
-+ scatt.CleanUp()
++ if scatt['scatt']:
++ scatt['scatt'].CleanUp()
+
+ def _initSettings(self):
+ """!Initialization of settings (if not already defined)"""
@@ -766,61 +3775,6 @@
+ value = init[2],
+ overwrite = False)
+
-+ def OnThreadDone(self, event):
-+
-+ if event.exception:
-+ GError(str(event.exception))
-+ return
-+
-+ if event.pid in self.tasks_pids['mapwin_conn']:
-+ self.tasks_pids['mapwin_conn'].remove(event.pid)
-+ updated_cats = event.ret
-+
-+ for cat in updated_cats:
-+ if cat not in self.cats_to_update:
-+ self.cats_to_update.append(cat)
-+
-+ if not self.tasks_pids['mapwin_conn']:
-+ self.tasks_pids['render_plots'] = self.thread.GetId()
-+ self.thread.Run(callable = self.core.ComputeCatsScatts,
-+ cats_ids = self.cats_to_update[:])
-+ del self.cats_to_update[:]
-+
-+ return
-+
-+ if self.tasks_pids['render_plots'] == event.pid:
-+ self.RenderScattPlts()
-+ return
-+
-+ if event.pid in self.tasks_pids['render']:
-+ self.tasks_pids['render'].remove(event.pid)
-+ if not self.tasks_pids['render']:
-+ self.renderingFinished.emit()
-+ return
-+
-+ if event.pid in self.tasks_pids['add_scatt']:
-+ self.tasks_pids['add_scatt'].remove(event.pid)
-+ self.AddScattPlotDone(event)
-+ return
-+
-+ if self.tasks_pids['set_data'] == event.pid:
-+ self.SetDataDone(event)
-+ return
-+
-+ if self.tasks_pids['set_data_add'] == event.pid:
-+ self.SetDataDone(event)
-+ self.AddScattPlot()
-+ return
-+
-+ if self.tasks_pids['set_edit_cat_data'] == event.pid:
-+ self.SetEditCatDataDone(event)
-+ return
-+
-+ if event.pid in self.tasks_pids['export_cat_rast']:
-+ self.cats_mgr.OnExportCatRastDone(event)
-+ return
-+
-+
+ def SetData(self):
+ self.iclass_conn.SetData()
+
@@ -829,19 +3783,23 @@
+ self.data_set = False
+
+ if self.show_add_scatt_plot:
-+ self.tasks_pids['set_data_add'] = self.thread.GetId()
++ show_add=True
+ else:
-+ self.tasks_pids['set_data'] = self.thread.GetId()
++ show_add=False
+
-+ self.thread.Run(callable=self.core.SetData, bands=bands)
++ self.thread.Run(callable=self.core.SetData, bands=bands,
++ ondone=self.SetDataDone, userdata={"show_add" : show_add})
+
+ def SetDataDone(self, event):
+ self.data_set = True
++
+ self.iclass_conn.SyncCats()
++ if event.userdata['show_add']:
++ self.AddScattPlot()
+
+ def SettingsUpdated(self, event):
+ #TODO optimization
-+ self.RenderScattPlts()
++ self.render_mgr.RenderScattPlts()
+
+ def OnOutput(self, event):
+ """!Print thread output according to debug level.
@@ -864,115 +3822,62 @@
+ self.computingStarted.emit()
+
+ bands = self.core.GetBands()
-+ dlg = AddScattPlotDialog(parent = self.guiparent, bands = bands)
++
++ #added_bands_ids = []
++ #for scatt_id in self.plots):
++ # added_bands_ids.append[idBandsToidScatt(scatt_id)]
++
++ self.digit_conn.Update()
++ dlg = AddScattPlotDialog(parent = self.guiparent,
++ bands = bands,
++ added_scatts_ids = self.plots.keys())
+ if dlg.ShowModal() == wx.ID_OK:
+
-+ b_1, b_2 = dlg.GetBands()
++ scatt_ids = []
++ sel_bands = dlg.GetBands()
++
++ for b_1, b_2 in sel_bands:
+
-+ #TODO axes selection
-+ transpose = False
-+ if b_1 > b_2:
-+ transpose = True
-+ tmp_band = b_2
-+ b_2 = b_1
-+ b_1 = tmp_band
++ transpose = False
++ if b_1 > b_2:
++ transpose = True
++ tmp_band = b_2
++ b_2 = b_1
++ b_1 = tmp_band
+
-+ self.scatt_id = idBandsToidScatt(b_1, b_2, len(bands))
-+ self._addScattPlot(self.scatt_id, transpose)
++ scatt_id = idBandsToidScatt(b_1, b_2, len(bands))
++ if self.plots.has_key(scatt_id):
++ continue
++
++ self.plots[scatt_id] = {'transpose' : transpose,
++ 'scatt' : None}
++ scatt_ids.append(scatt_id)
+
++ self._addScattPlot(scatt_ids)
++
+ dlg.Destroy()
-+
-+ self.digit_conn.Update()
+
-+ def _addScattPlot(self, scatt_id, transpose):
-+ if self.plots.has_key(scatt_id):
-+ GMessage(_("Scatter plot has been already added."))
-+ return
++ def _addScattPlot(self, scatt_ids):
++ self.thread.Run(callable=self.core.AddScattPlots,
++ scatt_ids=scatt_ids, ondone=self.AddScattPlotDone)
+
-+ self.tasks_pids['add_scatt'].append(self.thread.GetId())
-+
-+ self.thread.Run(callable = self.core.AddScattPlot,
-+ scatt_id = scatt_id,
-+ userdata = {'transpose' : transpose})
-+
-+ def RenderScattPlts(self, scatt_ids = None):
-+ if len(self.tasks_pids['render']) > 1:
-+ return
-+
-+ self.renderingStarted.emit()
-+ self.tasks_pids['render'].append(self.thread.GetId())
-+ self.thread.Run(callable = self._renderscattplts, scatt_ids = scatt_ids)
-+
-+ def _renderscattplts(self, scatt_ids):
-+ cats_attrs = self.cats_mgr.GetCategoriesAttrs()
-+ cats = self.cats_mgr.GetCategories()[:]
-+ cats.reverse()
-+ cats.insert(0, 0)
-+ for i_scatt_id, scatt in self.plots.items():
-+ if scatt_ids is not None and i_scatt_id not in scatt_ids:
-+ continue
-+
-+ scatt_dt = self.scatts_dt.GetScatt(i_scatt_id)
-+ if self._showConfEllipses():
-+ ellipses_dt = self.scatts_dt.GetEllipses(i_scatt_id, cats_attrs)
-+ else:
-+ ellipses_dt = {}
-+
-+ if self.pol_sel_mode[0]:
-+ self._getSelectedAreas(cats, i_scatt_id, scatt_dt, cats_attrs)
-+
-+ scatt.Plot(cats_order = cats, scatts = scatt_dt, ellipses = ellipses_dt, styles = cats_attrs)
-+
-+ def _showConfEllipses(self):
-+ return UserSettings.Get(group='scatt',
-+ key="ellipses",
-+ subkey="show_ellips")
-+
-+ def _getSelectedAreas(self, cats_order, scatt_id, scatt_dt, cats_attrs):
-+
-+ cat_id = self.cats_mgr.GetSelectedCat()
-+ if not cat_id:
-+ return
-+
-+ sel_a_cat_id = max(cats_attrs.keys()) + 1
-+
-+ s = self.scatt_conds_dt.GetScatt(scatt_id, [cat_id])
-+ if not s:
-+ return
-+
-+ cats_order.append(sel_a_cat_id)
-+
-+ col = UserSettings.Get(group='scatt',
-+ key='selection',
-+ subkey='sel_area')
-+
-+ col = ":".join(map(str, col))
-+ opac = UserSettings.Get(group='scatt',
-+ key='selection',
-+ subkey='sel_area_opacty') / 100.0
-+
-+ cats_attrs[sel_a_cat_id] = {'color' : col,
-+ 'opacity' : opac,
-+ 'show' : True}
-+
-+ scatt_dt[sel_a_cat_id] = s[cat_id]
-+
+ def AddScattPlotDone(self, event):
-+
-+ transpose = event.userdata['transpose']
-+ scatt_id = event.kwds['scatt_id']
+
-+ #TODO guiparent - not very good
-+ self.plots[scatt_id] = self.guiparent.NewScatterPlot(scatt_id = scatt_id, transpose = transpose)
++ scatt_ids = event.kwds['scatt_ids']
++ for s_id in scatt_ids:
++ trans = self.plots[s_id]['transpose']
++ self.plots[s_id]['scatt'] = self.guiparent.NewScatterPlot(scatt_id=s_id,
++ transpose=trans)
+
-+ self.plots[scatt_id].plotClosed.connect(self.PlotClosed)
-+ self.plots[scatt_id].cursorMove.connect(lambda x, y: self.cursorPlotMove.emit(x = x, y = y))
++ self.plots[s_id]['scatt'].plotClosed.connect(self.PlotClosed)
++ self.plots[s_id]['scatt'].cursorMove.connect(lambda x, y:
++ self.cursorPlotMove.emit(x=x, y=y))
+
-+ if self.plot_mode:
-+ self.plots[scatt_id].SetMode(self.plot_mode)
-+ self.plots[scatt_id].ZoomToExtend()
++ if self.plot_mode:
++ self.plots[s_id]['scatt'].SetMode(self.plot_mode)
++ self.plots[s_id]['scatt'].ZoomToExtend()
+
-+ self.RenderScattPlts(scatt_ids = [scatt_id])
++ self.render_mgr.RenderScattPlts(scatt_ids = scatt_ids)
+
+ def PlotClosed(self, scatt_id):
+ del self.plots[scatt_id]
@@ -981,24 +3886,29 @@
+
+ self.plot_mode = mode
+ for scatt in self.plots.itervalues():
-+ scatt.SetMode(mode)
++ if scatt['scatt']:
++ scatt['scatt'].SetMode(mode)
+
+ self.modeSet.emit(mode = mode)
+
+ def ActivateSelectionPolygonMode(self, activate):
+ self.pol_sel_mode[0] = activate
+ for scatt in self.plots.itervalues():
-+ scatt.SetSelectionPolygonMode(activate)
++ if not scatt['scatt']:
++ continue
++ scatt['scatt'].SetSelectionPolygonMode(activate)
+ if not activate and self.plot_mode not in ['zoom', 'pan', 'zoom_extend']:
+ self.SetPlotsMode(None)
+
-+ self.RenderScattPlts()
++ self.render_mgr.RenderScattPlts()
+ return activate
+
+ def ProcessSelectionPolygons(self, process_mode):
+ scatts_polygons = {}
+ for scatt_id, scatt in self.plots.iteritems():
-+ coords = scatt.GetCoords()
++ if not scatt['scatt']:
++ continue
++ coords = scatt['scatt'].GetCoords()
+ if coords is not None:
+ scatts_polygons[scatt_id] = coords
+
@@ -1025,16 +3935,15 @@
+ if not sel_cat_id:
+ return
+
-+ #for scatt in self.plots.itervalues():
-+ # scatt.SetEmpty()
++ for scatt in self.plots.itervalues():
++ scatt['scatt'].SetEmpty()
+
+ self.computingStarted.emit()
+
-+ self.tasks_pids['set_edit_cat_data'] = self.thread.GetId()
+ self.thread.Run(callable = self.core.UpdateCategoryWithPolygons,
+ cat_id = sel_cat_id,
+ scatts_pols = scatts_polygons,
-+ value = value)
++ value = value, ondone=self.SetEditCatDataDone)
+
+ def SetEditCatDataDone(self, event):
+ if event.exception:
@@ -1043,7 +3952,7 @@
+
+ cat_id = event.ret
+
-+ self.RenderScattPlts()
++ self.render_mgr.RenderScattPlts()
+ self.iclass_conn.RenderCatRast(cat_id)
+
+ def DigitDataChanged(self, vectMap, digit):
@@ -1057,6 +3966,92 @@
+ def GetCategoriesManager(self):
+ return self.cats_mgr
+
++class RenderingManager:
++
++ def __init__(self, scatt_mgr, cats_mgr, core):
++ self.scatt_mgr = scatt_mgr
++ self.cats_mgr = cats_mgr
++ self.core = core
++ self.scatts_dt, self.scatt_conds_dt = self.core.GetScattsData()
++
++ self.scatts_to_render = {}
++ self.render_queue = []
++
++ self.renderingStarted = Signal("ScattsManager.renderingStarted")
++ self.renderingFinished = Signal("ScattsManager.renderingFinished")
++
++ def RenderScattPlts(self, scatt_ids = None):
++ if len(self.render_queue) > 1:
++ return
++
++ self.renderingStarted.emit()
++ self.render_queue.append(self.scatt_mgr.thread.GetId())
++ self.scatt_mgr.thread.Run(callable = self._renderscattplts, scatt_ids = scatt_ids,
++ ondone=self.RenderingDone)
++
++ def _renderscattplts(self, scatt_ids):
++ cats_attrs = self.cats_mgr.GetCategoriesAttrs()
++ cats = self.cats_mgr.GetCategories()[:]
++ cats.reverse()
++ cats.insert(0, 0)
++ for i_scatt_id, scatt in self.scatt_mgr.plots.items():
++ if scatt_ids is not None and \
++ i_scatt_id not in scatt_ids:
++ continue
++ if not scatt['scatt']:
++ continue
++
++ scatt_dt = self.scatts_dt.GetScatt(i_scatt_id)
++ if self._showConfEllipses():
++ ellipses_dt = self.scatts_dt.GetEllipses(i_scatt_id, cats_attrs)
++ else:
++ ellipses_dt = {}
++
++ if self.scatt_mgr.pol_sel_mode[0]:
++ self._getSelectedAreas(cats, i_scatt_id, scatt_dt, cats_attrs)
++
++ scatt['scatt'].Plot(cats_order = cats, scatts = scatt_dt, ellipses = ellipses_dt, styles = cats_attrs)
++
++ def RenderingDone(self, event):
++ self.render_queue.remove(event.pid)
++ if not self.render_queue:
++ self.renderingFinished.emit()
++
++ def _getSelectedAreas(self, cats_order, scatt_id, scatt_dt, cats_attrs):
++
++ cat_id = self.cats_mgr.GetSelectedCat()
++ if not cat_id:
++ return
++
++ sel_a_cat_id = max(cats_attrs.keys()) + 1
++
++ s = self.scatt_conds_dt.GetScatt(scatt_id, [cat_id])
++ if not s:
++ return
++
++ cats_order.append(sel_a_cat_id)
++
++ col = UserSettings.Get(group='scatt',
++ key='selection',
++ subkey='sel_area')
++
++ col = ":".join(map(str, col))
++ opac = UserSettings.Get(group='scatt',
++ key='selection',
++ subkey='sel_area_opacty') / 100.0
++
++ cats_attrs[sel_a_cat_id] = {'color' : col,
++ 'opacity' : opac,
++ 'show' : True}
++
++ scatt_dt[sel_a_cat_id] = s[cat_id]
++
++
++ def _showConfEllipses(self):
++ return UserSettings.Get(group='scatt',
++ key="ellipses",
++ subkey="show_ellips")
++
+class CategoriesManager:
+
+ def __init__(self, scatt_mgr, core):
@@ -1099,7 +4094,7 @@
+
+ self.cats_ids.insert(new_pos, cat_id)
+
-+ self.scatt_mgr.RenderScattPlts()
++ self.scatt_mgr.render_mgr.RenderScattPlts()
+ return True
+
+ def _addCategory(self, cat_id):
@@ -1158,7 +4153,7 @@
+ self.cats[cat_id][k] = v
+
+ if render:
-+ self.scatt_mgr.RenderScattPlts()
++ self.scatt_mgr.render_mgr.RenderScattPlts()
+
+ if update_cat_rast:
+ self.scatt_mgr.iclass_conn.UpdateCategoryRaster(cat_id, update_cat_rast)
@@ -1179,7 +4174,7 @@
+ def SetSelectedCat(self, cat_id):
+ self.sel_cat_id = cat_id
+ if self.scatt_mgr.pol_sel_mode[0]:
-+ self.scatt_mgr.RenderScattPlts()
++ self.scatt_mgr.render_mgr.RenderScattPlts()
+
+ def GetSelectedCat(self):
+ return self.sel_cat_id
@@ -1213,11 +4208,11 @@
+ self.exportCatRast = dlg.GetRasterName()
+ dlg.Destroy()
+
-+ self.scatt_mgr.tasks_pids['export_cat_rast'].append(self.scatt_mgr.thread.GetId())
+ self.scatt_mgr.thread.Run(callable=self.core.ExportCatRast,
+ userdata={'name' : cat_attrs['name']},
+ cat_id=cat_id,
-+ rast_name=self.exportCatRast)
++ rast_name=self.exportCatRast,
++ ondone=self.cats_mgr.OnExportCatRastDone)
+
+ def OnExportCatRastDone(self, event):
+ ret, err = event.ret
@@ -1242,13 +4237,16 @@
+ self.scatt_mgr = scatt_mgr
+ self.cats_mgr = scatt_mgr.cats_mgr
+
++ self.cats_to_update = []
++ self.tasks_pids = {'mapwin_conn' : []}
++
+ self.thread = self.scatt_mgr.thread
+
+ #TODO
+ self.mapWin.parent.toolbars["vdigit"].editingStarted.connect(self.DigitDataChanged)
+
+ def Update(self):
-+ self.thread.Run(callable=self.scatt_rast_updater.SynchWithMap)
++ self.thread.Run(callable=self.scatt_rast_updater.SyncWithMap)
+
+ def _connectSignals(self):
+ self.digit.featureAdded.connect(self.AddFeature)
@@ -1264,36 +4262,39 @@
+ return
+ self.scatt_mgr.computingStarted.emit()
+
-+ self.scatt_mgr.tasks_pids['mapwin_conn'].append(self.thread.GetId())
++ self.tasks_pids['mapwin_conn'].append(self.thread.GetId())
+ self.thread.Run(callable = self.scatt_rast_updater.EditedFeature,
+ new_bboxs = new_bboxs,
+ old_bboxs = [],
+ old_areas_cats = [],
-+ new_areas_cats = new_areas_cats)
++ new_areas_cats = new_areas_cats,
++ ondone=self.OnDone)
+
+ def DeleteAreas(self, old_bboxs, old_areas_cats):
+ if not self.scatt_mgr.data_set:
+ return
+ self.scatt_mgr.computingStarted.emit()
+
-+ self.scatt_mgr.tasks_pids['mapwin_conn'].append(self.thread.GetId())
++ self.tasks_pids['mapwin_conn'].append(self.thread.GetId())
+ self.thread.Run(callable = self.scatt_rast_updater.EditedFeature,
+ new_bboxs = [],
+ old_bboxs = old_bboxs,
+ old_areas_cats = old_areas_cats,
-+ new_areas_cats = [])
++ new_areas_cats = [],
++ ondone=self.OnDone)
+
+ def EditedFeature(self, new_bboxs, new_areas_cats, old_bboxs, old_areas_cats):
+ if not self.scatt_mgr.data_set:
+ return
+ self.scatt_mgr.computingStarted.emit()
+
-+ self.scatt_mgr.tasks_pids['mapwin_conn'].append(self.thread.GetId())
++ self.tasks_pids['mapwin_conn'].append(self.thread.GetId())
+ self.thread.Run(callable = self.scatt_rast_updater.EditedFeature,
+ new_bboxs = new_bboxs,
+ old_bboxs = old_bboxs,
+ old_areas_cats = old_areas_cats,
-+ new_areas_cats = new_areas_cats)
++ new_areas_cats = new_areas_cats,
++ ondone=self.OnDone)
+
+ def DigitDataChanged(self, vectMap, digit):
+
@@ -1306,6 +4307,22 @@
+
+ self._connectSignals()
+
++ def OnDone(self, event):
++ self.tasks_pids['mapwin_conn'].remove(event.pid)
++ updated_cats = event.ret
++ for cat in updated_cats:
++ if cat not in self.cats_to_update:
++ self.cats_to_update.append(cat)
++
++ if not self.tasks_pids['mapwin_conn']:
++ self.tasks_pids['render_plots'] = self.thread.GetId()
++ self.thread.Run(callable = self.scatt_mgr.core.ComputeCatsScatts,
++ cats_ids = self.cats_to_update[:], ondone=self.Render)
++ del self.cats_to_update[:]
++
++ def Render(self, event):
++ self.scatt_mgr.render_mgr.RenderScattPlts()
++
+class IMapDispConnection:
+ def __init__(self, scatt_mgr, cats_mgr, giface):
+ self.scatt_mgr = scatt_mgr
@@ -1416,6 +4433,9 @@
+ return
+
+ cat_rast = self.scatt_mgr.core.GetCatRast(cat_id)
++ if not cat_rast:
++ return
++
+ if not grass.find_file(cat_rast, element = 'cell', mapset = '.')['file']:
+ return
+ cats_attrs = self.cats_mgr.GetCategoryAttrs(cat_id)
@@ -1538,7 +4558,7 @@
===================================================================
--- gui/wxpython/scatt_plot/gthreading.py (revision 0)
+++ gui/wxpython/scatt_plot/gthreading.py (working copy)
-@@ -0,0 +1,134 @@
+@@ -0,0 +1,125 @@
+"""!
+ at package scatt_plot.gthreading
+
@@ -1557,18 +4577,21 @@
+import time
+import threading
+import Queue
++from core.gconsole import EVT_CMD_DONE
+
+import wx
+from core.gconsole import wxCmdRun, wxCmdDone, wxCmdPrepare
+
-+class gThread(threading.Thread):
++class gThread(threading.Thread, wx.EvtHandler):
+ """!Thread for GRASS commands"""
+ requestId = 0
+
-+ def __init__(self, receiver, requestQ=None, resultQ=None, **kwds):
++ def __init__(self, requestQ=None, resultQ=None, **kwds):
+ """!
+ @param receiver event receiver (used in PostEvent)
+ """
++ wx.EvtHandler.__init__(self)
++
+ threading.Thread.__init__(self, **kwds)
+
+ if requestQ is None:
@@ -1583,9 +4606,9 @@
+
+ self.setDaemon(True)
+
-+ self.receiver = receiver
+ self._want_abort_all = False
+
++ self.Bind(EVT_CMD_DONE, self.OnDone)
+ self.start()
+
+ def Run(self, *args, **kwds):
@@ -1613,7 +4636,7 @@
+ os.environ['GRASS_MESSAGE_FORMAT'] = 'gui'
+ while True:
+ requestId, args, kwds = self.requestQ.get()
-+ for key in ('callable', 'onDone', 'onPrepare', 'userdata'):
++ for key in ('callable', 'ondone', 'userdata'):
+ if key in kwds:
+ vars()[key] = kwds[key]
+ del kwds[key]
@@ -1628,24 +4651,10 @@
+ # self._want_abort_all = False
+
+ # prepare
-+ if self.receiver:
-+ event = wxCmdPrepare(type = 'method',
-+ time=requestTime,
-+ pid=requestId)
-+
-+ wx.PostEvent(self.receiver, event)
-+
-+ # run command
-+ event = wxCmdRun(type = 'method',
-+ pid=requestId)
-+
-+ wx.PostEvent(self.receiver, event)
-+
++ ret = None
++ exception = None
+ time.sleep(.1)
+
-+ ret = None
-+ exception = None
-+
+ #to
+ #try:
+ ret = vars()['callable'](*args, **kwds)
@@ -1654,18 +4663,20 @@
+
+ self.resultQ.put((requestId, ret))
+
-+ time.sleep(.1)
++ event = wxCmdDone(ondone=vars()['ondone'],
++ kwds=kwds,
++ args=args, #TODO expand args to kwds
++ ret=ret,
++ exception=exception,
++ userdata=vars()['userdata'],
++ pid=requestId)
+
-+ if self.receiver:
-+ event = wxCmdDone(kwds=kwds,
-+ args=args, #TODO expand args to kwds
-+ ret=ret,
-+ exception=exception,
-+ userdata=vars()['userdata'],
-+ pid=requestId)
++ # send event
++ wx.PostEvent(self, event)
+
-+ # send event
-+ wx.PostEvent(self.receiver, event)
++ def OnDone(self, event):
++ if event.ondone:
++ event.ondone(event)
+
+ def abort(self, abortall=True):
+ """!Abort command(s)"""
@@ -1678,7 +4689,7 @@
===================================================================
--- gui/wxpython/scatt_plot/dialogs.py (revision 0)
+++ gui/wxpython/scatt_plot/dialogs.py (working copy)
-@@ -0,0 +1,419 @@
+@@ -0,0 +1,468 @@
+"""!
+ at package scatt_plot.dialogs
+
@@ -1704,20 +4715,23 @@
+import grass.script as grass
+
+from core import globalvar
-+from core.gcmd import GError
++from core.gcmd import GMessage
+from core.settings import UserSettings
+
+class AddScattPlotDialog(wx.Dialog):
+
-+ def __init__(self, parent, bands, id = wx.ID_ANY):
++ def __init__(self, parent, bands, added_scatts_ids, id = wx.ID_ANY):
+
-+ wx.Dialog.__init__(self, parent, title = ("Add scatter plot"), id = id)
++ wx.Dialog.__init__(self, parent, title = ("Add scatter plots"), id = id)
+
++ self.added_scatts_ids = added_scatts_ids
+ self.bands = bands
+
+ self.x_band = None
+ self.y_band = None
+
++ self.added_bands_ids = []
++ self.sel_bands_ids = []
+ self._createWidgets()
+
+ def _createWidgets(self):
@@ -1725,22 +4739,27 @@
+ self.labels = {}
+ self.params = {}
+
-+ self.band_1_label = wx.StaticText(parent = self, id = wx.ID_ANY, label = _("%s axis:" % "x"))
++ self.band_1_label = wx.StaticText(parent = self, id = wx.ID_ANY, label = _("x axis:"))
+
+ self.band_1_ch = wx.ComboBox(parent = self, id = wx.ID_ANY,
+ choices = self.bands,
+ style = wx.CB_READONLY, size = (350, 30))
+
-+ self.band_2_label = wx.StaticText(parent = self, id = wx.ID_ANY, label = _("%s axis:" % "y"))
++ self.band_2_label = wx.StaticText(parent = self, id = wx.ID_ANY, label = _("y axis:"))
+
+ self.band_2_ch = wx.ComboBox(parent = self, id = wx.ID_ANY,
+ choices = self.bands,
+ style = wx.CB_READONLY, size = (350, 30))
+
++ self.scattsBox = wx.ListBox(parent = self, id = wx.ID_ANY, size = (-1, 150),
++ style = wx.LB_MULTIPLE | wx.LB_NEEDED_SB)
++
+ # buttons
-+ self.btn_close = wx.Button(parent = self, id = wx.ID_CANCEL)
++ self.btn_add = wx.Button(parent=self, id=wx.ID_ANY, label = _("Add"))
++ self.btn_remove = wx.Button(parent=self, id=wx.ID_ANY, label = _("Remove"))
+
-+ self.btn_ok = wx.Button(parent = self, id = wx.ID_OK, label = _("&OK"))
++ self.btn_close = wx.Button(parent=self, id=wx.ID_CANCEL)
++ self.btn_ok = wx.Button(parent=self, id=wx.ID_OK, label = _("&OK"))
+
+ self._layout()
+
@@ -1757,22 +4776,34 @@
+ dialogSizer.Add(item = self._addSelectSizer(title = self.band_2_label,
+ sel = self.band_2_ch))
+
++
++ dialogSizer.Add(item=self.btn_add, proportion=0, flag = wx.TOP, border = 5)
++
++ box = wx.StaticBox(self, id = wx.ID_ANY,
++ label = " %s " % _("Bands of scatter plots to be added (x y):"))
++ sizer = wx.StaticBoxSizer(box, wx.VERTICAL)
++
++ sizer.Add(item=self.scattsBox, proportion=1, flag=wx.EXPAND | wx.TOP, border=5)
++ sizer.Add(item=self.btn_remove, proportion=0, flag=wx.TOP, border = 5)
++
++ dialogSizer.Add(item=sizer, proportion=1, flag = wx.EXPAND | wx.TOP, border = 5)
++
+ # buttons
+ self.btnsizer = wx.BoxSizer(orient = wx.HORIZONTAL)
+
+ self.btnsizer.Add(item = self.btn_close, proportion = 0,
-+ flag = wx.ALL | wx.ALIGN_CENTER,
++ flag = wx.RIGHT | wx.LEFT | wx.ALIGN_CENTER,
+ border = 10)
+
+ self.btnsizer.Add(item = self.btn_ok, proportion = 0,
-+ flag = wx.ALL | wx.ALIGN_CENTER,
++ flag = wx.RIGHT | wx.LEFT | wx.ALIGN_CENTER,
+ border = 10)
+
+ dialogSizer.Add(item = self.btnsizer, proportion = 0,
-+ flag = wx.ALIGN_CENTER)
++ flag = wx.ALIGN_CENTER | wx.TOP, border = 5)
+
+ border.Add(item = dialogSizer, proportion = 0,
-+ flag = wx.ALL, border = 5)
++ flag = wx.LEFT | wx.RIGHT | wx.BOTTOM, border = 10)
+
+ self.SetSizer(border)
+ self.Layout()
@@ -1781,7 +4812,17 @@
+ # bindings
+ self.btn_close.Bind(wx.EVT_BUTTON, self.OnClose)
+ self.btn_ok.Bind(wx.EVT_BUTTON, self.OnOk)
++ self.btn_add.Bind(wx.EVT_BUTTON, self.OnAdd)
++ self.btn_remove.Bind(wx.EVT_BUTTON, self.OnRemoveLayer)
+
++ def OnOk(self, event):
++
++ if not self.GetBands():
++ GMessage(parent=self, message=_("No scatter plots selected."))
++ return
++
++ event.Skip()
++
+ def _addSelectSizer(self, title, sel):
+ """!Helper layout function.
+ """
@@ -1789,17 +4830,21 @@
+
+ selTitleSizer = wx.BoxSizer(wx.HORIZONTAL)
+ selTitleSizer.Add(item = title, proportion = 1,
-+ flag = wx.LEFT | wx.TOP | wx.EXPAND, border = 5)
++ flag = wx.TOP | wx.EXPAND, border = 5)
+
+ selSizer.Add(item = selTitleSizer, proportion = 0,
+ flag = wx.EXPAND)
+
+ selSizer.Add(item = sel, proportion = 1,
-+ flag = wx.EXPAND | wx.ALL| wx.ALIGN_CENTER_VERTICAL,
++ flag = wx.EXPAND | wx.TOP| wx.ALIGN_CENTER_VERTICAL,
+ border = 5)
+
+ return selSizer
+
++ def GetBands(self):
++ """!Get layers"""
++ return self.sel_bands_ids
++
+ def OnClose(self, event):
+ """!Close dialog
+ """
@@ -1807,34 +4852,49 @@
+ self.Destroy()
+ event.Skip()
+
-+ def OnOk(self, event):
++ def OnRemoveLayer(self, event):
++ """!Remove layer from listbox"""
++ while self.scattsBox.GetSelections():
++ sel = self.scattsBox.GetSelections()[0]
++ self.scattsBox.Delete(sel)
++ self.sel_bands_ids.pop(sel)
++
++ def OnAdd(self, event):
+ """!
+ """
+ b_x = self.band_1_ch.GetSelection()
+ b_y = self.band_2_ch.GetSelection()
+
-+ err = True
-+
+ if b_x < 0 or b_y < 0:
-+ GError(_("Select both x and y bands."))
-+ elif b_y == b_x:
-+ GError(_("Selected bands must be different."))
-+ else:
-+ err = False
++ GMessage(parent=self, message=_("Select both x and y bands."))
++ return
++ if b_y == b_x:
++ GMessage(parent=self, message=_("Selected bands must be different."))
++ return
+
-+ if err:
-+ self.band_y = None
-+ self.band_x = None
++ scatt_id = idBandsToidScatt(b_x, b_y, len(self.bands))
++ if scatt_id in self.added_scatts_ids:
++ GMessage(parent=self,
++ message=_("Scatter plot with same band combination (regardless x y order) "
++ "is already displayed."))
+ return
+
-+ self.band_y = b_y
-+ self.band_x = b_x
++ if [b_x, b_y] in self.sel_bands_ids or [b_y, b_x] in self.sel_bands_ids:
++ GMessage(parent=self,
++ message=_("Scatter plot with same bands combination (regardless x y order) "
++ "has been already added into the list."))
++ return
+
++ self.sel_bands_ids.append([b_x, b_y])
++
++ b_x_str = self.band_1_ch.GetStringSelection()
++ b_y_str = self.band_2_ch.GetStringSelection()
++
++ text = b_x_str + " " + b_y_str
++
++ self.scattsBox.Append(text)
+ event.Skip()
+
-+ def GetBands(self):
-+ return (self.band_x, self.band_y)
-+
+class ExportCategoryRaster(wx.Dialog):
+ def __init__(self, parent, title, rasterName = None, id = wx.ID_ANY,
+ style = wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER,
@@ -2373,7 +5433,7 @@
===================================================================
--- gui/wxpython/scatt_plot/scatt_core.py (revision 0)
+++ gui/wxpython/scatt_plot/scatt_core.py (working copy)
-@@ -0,0 +1,813 @@
+@@ -0,0 +1,811 @@
+"""!
+ at package scatt_plot.scatt_plot
+
@@ -2450,9 +5510,10 @@
+ def GetCatRast(self, cat_id):
+ return self.scatts_dt.GetCatRast(cat_id)
+
-+ def AddScattPlot(self, scatt_id):
++ def AddScattPlots(self, scatt_ids):
+
-+ self.scatts_dt.AddScattPlot(scatt_id = scatt_id)
++ for s_id in scatt_ids:
++ self.scatts_dt.AddScattPlot(scatt_id = s_id)
+
+ cats_ids = self.scatts_dt.GetCategories()
+ self.ComputeCatsScatts(cats_ids)
@@ -2471,12 +5532,8 @@
+ bbox[k] = self._validExtend(v)
+
+ arr[bbox['btm_y'] : bbox['up_y'], bbox['btm_x'] : bbox['up_x']] = value
-+ #arr.flush()
-+ #del arr
+
+ self.ComputeCatsScatts([cat_id])
-+ #print "time"
-+ #print time.clock() - start_time
+ return cat_id
+
+ def ComputeCatsScatts(self, cats_ids):
@@ -2568,7 +5625,7 @@
+ def SetVectMap(self, vectMap):
+ self.vectMap = vectMap
+
-+ def SynchWithMap(self):
++ def SyncWithMap(self):
+ #TODO possible optimization - bbox only of vertex and its two neighbours
+
+ region = self.an_data.GetRegion()
@@ -3109,7 +6166,9 @@
+ self.cats_rasts_conds = {}
+
+ def GetCatRast(self, cat_id):
-+ return self.cats_rasts[cat_id]
++ if self.cats_rasts.has_key(cat_id):
++ return self.cats_rasts[cat_id]
++ return None
+
+ def GetCatRastCond(self, cat_id):
+ return self.cats_rasts_conds[cat_id]
@@ -3177,7 +6236,7 @@
+def idBandsToidScatt(band_1_id, band_2_id, n_bands):
+
+ if band_2_id < band_1_id:
-+ tmp = band_1
++ tmp = band_1_id
+ band_1_id = band_2_id
+ band_2_id = tmp
+
@@ -3186,7 +6245,7 @@
+ scatt_id = (band_1_id * (2 * n_b1 + 1) - band_1_id * band_1_id) / 2 + band_2_id - band_1_id - 1
+
+ return scatt_id
-+
+\ No newline at end of file
Index: gui/wxpython/scatt_plot/core_c.py
===================================================================
--- gui/wxpython/scatt_plot/core_c.py (revision 0)
@@ -3428,7 +6487,7 @@
===================================================================
--- gui/wxpython/scatt_plot/frame.py (revision 0)
+++ gui/wxpython/scatt_plot/frame.py (working copy)
-@@ -0,0 +1,815 @@
+@@ -0,0 +1,811 @@
+"""!
+ at package scatt_plot.dialogs
+
@@ -3579,7 +6638,9 @@
+ pass
+
+ def _createCategoryToolbar(self, parent):
-+ return None
++ return CategoryToolbar(parent=parent,
++ scatt_mgr=self.scatt_mgr,
++ cats_list=self.cats_list)
+
+class IScattDialog(wx.Dialog):
+ def __init__(self, parent, giface, title=_("GRASS GIS Interactive Scatter Plot Tool"),
@@ -3608,11 +6669,6 @@
+ IClassIScattPanel.__init__(self, parent=parent, giface=giface,
+ id=id, style=style, **kwargs)
+
-+ def _createCategoryToolbar(self, parent):
-+ return CategoryToolbar(parent=parent,
-+ scatt_mgr=self.scatt_mgr,
-+ cats_list=self.cats_list)
-+
+ def _createScattMgr(self, guiparent, giface, iclass_mapwin):
+ return ScattsManager(guiparent = self, giface = giface)
+
@@ -4227,7 +7283,6 @@
+ band_1 = self.band_1_ch.GetSelection()
+ band_2 = self.band_2_ch.GetSelection()
+
-+
+ if band_1 == band_2:
+ GError(_("Selected bands must be different."))
+ return
@@ -4244,2874 +7299,3 @@
+
+ def GetScattId(self):
+ return self.scatt_id
-Index: gui/wxpython/scatt_plot/__init__.py
-===================================================================
---- gui/wxpython/scatt_plot/__init__.py (revision 0)
-+++ gui/wxpython/scatt_plot/__init__.py (working copy)
-@@ -0,0 +1,11 @@
-+all = [
-+ 'dialogs',
-+ 'controllers',
-+ 'frame',
-+ 'gthreading',
-+ 'plots',
-+ 'scatt_core',
-+ 'toolbars',
-+ 'scatt_core',
-+ 'core_c',
-+ ]
-Index: gui/wxpython/scatt_plot/plots.py
-===================================================================
---- gui/wxpython/scatt_plot/plots.py (revision 0)
-+++ gui/wxpython/scatt_plot/plots.py (working copy)
-@@ -0,0 +1,943 @@
-+"""!
-+ at package scatt_plot.dialogs
-+
-+ at brief Ploting widgets.
-+
-+Classes:
-+
-+(C) 2013 by the GRASS Development Team
-+
-+This program is free software under the GNU General Public License
-+(>=v2). Read the file COPYING that comes with GRASS for details.
-+
-+ at author Stepan Turek <stepan.turek seznam.cz> (mentor: Martin Landa)
-+"""
-+import wx
-+import numpy as np
-+from math import ceil
-+#TODO testing
-+import time
-+from multiprocessing import Process, Queue
-+
-+from copy import deepcopy
-+from scatt_plot.core_c import MergeArrays, ApplyColormap
-+from core.settings import UserSettings
-+
-+try:
-+ import matplotlib
-+ matplotlib.use('WXAgg')
-+ from matplotlib.figure import Figure
-+ from matplotlib.backends.backend_wxagg import \
-+ FigureCanvasWxAgg as FigCanvas
-+ from matplotlib.lines import Line2D
-+ from matplotlib.artist import Artist
-+ from matplotlib.mlab import dist_point_to_segment
-+ from matplotlib.patches import Polygon, Ellipse, Rectangle
-+ import matplotlib.image as mi
-+ import matplotlib.colors as mcolors
-+ import matplotlib.cbook as cbook
-+except ImportError as e:
-+ raise ImportError(_("Unable to import matplotlib (try to install it).\n%s") % e)
-+
-+import grass.script as grass
-+from grass.pydispatch.signal import Signal
-+
-+class ScatterPlotWidget(wx.Panel):
-+ def __init__(self, parent, scatt_id, scatt_mgr, transpose,
-+ id = wx.ID_ANY):
-+
-+ wx.Panel.__init__(self, parent, id)
-+
-+ self.parent = parent
-+ self.full_extend = None
-+ self.mode = None
-+
-+ self._createWidgets()
-+ self._doLayout()
-+ self.scatt_id = scatt_id
-+ self.scatt_mgr = scatt_mgr
-+
-+ self.cidpress = None
-+ self.cidrelease = None
-+
-+ self.transpose = transpose
-+
-+ self.inverse = False
-+
-+ self.SetSize((200, 100))
-+ self.Layout()
-+
-+ self.base_scale = 1.2
-+ self.Bind(wx.EVT_CLOSE,lambda event : self.CleanUp())
-+
-+ self.plotClosed = Signal("ScatterPlotWidget.plotClosed")
-+ self.cursorMove = Signal("ScatterPlotWidget.cursorMove")
-+
-+ self.contex_menu = ScatterPlotContextMenu(plot = self)
-+
-+ self.ciddscroll = None
-+
-+ self.canvas.mpl_connect('motion_notify_event', self.Motion)
-+ self.canvas.mpl_connect('button_press_event', self.OnPress)
-+ self.canvas.mpl_connect('button_release_event', self.OnRelease)
-+ self.canvas.mpl_connect('draw_event', self.draw_callback)
-+
-+ def draw_callback(self, event):
-+ self.polygon_drawer.draw_callback(event)
-+ self.axes.draw_artist(self.zoom_rect)
-+
-+ def _createWidgets(self):
-+
-+ # Create the mpl Figure and FigCanvas objects.
-+ # 5x4 inches, 100 dots-per-inch
-+ #
-+ self.dpi = 100
-+ self.fig = Figure((1.0, 1.0), dpi=self.dpi)
-+ self.fig.autolayout = True
-+
-+ self.canvas = FigCanvas(self, -1, self.fig)
-+
-+ self.axes = self.fig.add_axes([0.0,0.0,1,1])
-+
-+ pol = Polygon(list(zip([0], [0])), animated=True)
-+ self.axes.add_patch(pol)
-+ self.polygon_drawer = PolygonDrawer(self.axes, pol = pol, empty_pol = True)
-+
-+ self.zoom_wheel_coords = None
-+ self.zoom_rect_coords = None
-+ self.zoom_rect = Polygon(list(zip([0], [0])), facecolor = 'none')
-+ self.zoom_rect.set_visible(False)
-+ self.axes.add_patch(self.zoom_rect)
-+
-+ def ZoomToExtend(self):
-+ if self.full_extend:
-+ self.axes.axis(self.full_extend)
-+ self.canvas.draw()
-+
-+ def SetMode(self, mode):
-+ self._deactivateMode()
-+ if mode == 'zoom':
-+ self.ciddscroll = self.canvas.mpl_connect('scroll_event', self.ZoomWheel)
-+ self.mode = 'zoom'
-+ elif mode == 'zoom_extend':
-+ self.mode = 'zoom_extend'
-+ elif mode == 'pan':
-+ self.mode = 'pan'
-+ elif mode:
-+ self.polygon_drawer.SetMode(mode)
-+
-+ def SetSelectionPolygonMode(self, activate):
-+ self.polygon_drawer.SetSelectionPolygonMode(activate)
-+
-+ def _deactivateMode(self):
-+ self.mode = None
-+ self.polygon_drawer.SetMode(None)
-+
-+ if self.ciddscroll:
-+ self.canvas.mpl_disconnect(self.ciddscroll)
-+
-+ self.zoom_rect.set_visible(False)
-+ self._stopCategoryEdit()
-+
-+ def GetCoords(self):
-+
-+ coords = self.polygon_drawer.GetCoords()
-+ if coords is None:
-+ return
-+
-+ if self.transpose:
-+ for c in coords:
-+ tmp = c[0]
-+ c[0] = c[1]
-+ c[1] = tmp
-+
-+ return coords
-+
-+ def SetEmpty(self):
-+ return self.polygon_drawer.SetEmpty()
-+
-+ def OnRelease(self, event):
-+ if not self.mode == "zoom": return
-+ self.zoom_rect.set_visible(False)
-+ self.ZoomRectangle(event)
-+ self.canvas.draw()
-+
-+ def OnPress(self, event):
-+ 'on button press we will see if the mouse is over us and store some data'
-+ if not event.inaxes:
-+ return
-+ if self.mode == "zoom_extend":
-+ self.ZoomToExtend()
-+
-+ if event.xdata and event.ydata:
-+ self.zoom_wheel_coords = { 'x' : event.xdata, 'y' : event.ydata}
-+ self.zoom_rect_coords = { 'x' : event.xdata, 'y' : event.ydata}
-+ else:
-+ self.zoom_wheel_coords = None
-+ self.zoom_rect_coords = None
-+
-+ def _stopCategoryEdit(self):
-+ 'disconnect all the stored connection ids'
-+
-+ if self.cidpress:
-+ self.canvas.mpl_disconnect(self.cidpress)
-+ if self.cidrelease:
-+ self.canvas.mpl_disconnect(self.cidrelease)
-+ #self.canvas.mpl_disconnect(self.cidmotion)
-+
-+ def _doLayout(self):
-+
-+ self.main_sizer = wx.BoxSizer(wx.VERTICAL)
-+ self.main_sizer.Add(self.canvas, 1, wx.LEFT | wx.TOP | wx.GROW)
-+ self.SetSizer(self.main_sizer)
-+ self.main_sizer.Fit(self)
-+
-+ def Plot(self, cats_order, scatts, ellipses, styles):
-+ """ Redraws the figure
-+ """
-+
-+ callafter_list = []
-+
-+ if self.full_extend:
-+ cx = self.axes.get_xlim()
-+ cy = self.axes.get_ylim()
-+ c = cx + cy
-+ else:
-+ c = None
-+
-+ #q = Queue()
-+ #p = Process(target=MergeImg, args=(cats_order, scatts, styles, self.transpose, q))
-+ #p.start()
-+ #merged_img, self.full_extend = q.get()
-+ #p.join()
-+
-+ merged_img, self.full_extend = MergeImg(cats_order, scatts, styles, None)
-+ self.axes.clear()
-+ self.axes.axis('equal')
-+
-+ if self.transpose:
-+ merged_img = np.transpose(merged_img, (1, 0, 2))
-+
-+ img = imshow(self.axes, merged_img,
-+ extent= [int(ceil(x)) for x in self.full_extend],
-+ origin='lower',
-+ interpolation='nearest',
-+ aspect="equal")
-+
-+ callafter_list.append([self.axes.draw_artist, [img]])
-+ callafter_list.append([grass.try_remove, [merged_img.filename]])
-+
-+ for cat_id in cats_order:
-+ if cat_id == 0:
-+ continue
-+ if not ellipses.has_key(cat_id):
-+ continue
-+
-+ e = ellipses[cat_id]
-+ if not e:
-+ continue
-+
-+ colors = styles[cat_id]['color'].split(":")
-+ if self.transpose:
-+ e['theta'] = 360 - e['theta'] + 90
-+ if e['theta'] >= 360:
-+ e['theta'] = abs(360 - e['theta'])
-+
-+ e['pos'] = [e['pos'][1], e['pos'][0]]
-+
-+ ellip = Ellipse(xy=e['pos'],
-+ width=e['width'],
-+ height=e['height'],
-+ angle=e['theta'],
-+ edgecolor="w",
-+ linewidth=1.5,
-+ facecolor='None')
-+ self.axes.add_artist(ellip)
-+ callafter_list.append([self.axes.draw_artist, [ellip]])
-+
-+ color = map(lambda v : int(v)/255.0, styles[cat_id]['color'].split(":"))
-+
-+ ellip = Ellipse(xy=e['pos'],
-+ width=e['width'],
-+ height=e['height'],
-+ angle=e['theta'],
-+ edgecolor=color,
-+ linewidth=1,
-+ facecolor='None')
-+
-+ self.axes.add_artist(ellip)
-+ callafter_list.append([self.axes.draw_artist, [ellip]])
-+
-+ center = Line2D([e['pos'][0]], [e['pos'][1]],
-+ marker='x',
-+ markeredgecolor='w',
-+ #markerfacecolor=color,
-+ markersize=2)
-+ self.axes.add_artist(center)
-+ callafter_list.append([self.axes.draw_artist, [center]])
-+
-+ callafter_list.append([self.fig.canvas.blit, []])
-+
-+ if c:
-+ self.axes.axis(c)
-+ wx.CallAfter(lambda : self.CallAfter(callafter_list))
-+
-+ def CallAfter(self, funcs_list):
-+ while funcs_list:
-+ fcn, args = funcs_list.pop(0)
-+ fcn(*args)
-+
-+ self.canvas.draw()
-+
-+ def CleanUp(self):
-+ self.plotClosed.emit(scatt_id = self.scatt_id)
-+ self.Destroy()
-+
-+ def ZoomWheel(self, event):
-+ # get the current x and y limits
-+ if not event.inaxes:
-+ return
-+ # tcaswell
-+ # http://stackoverflow.com/questions/11551049/matplotlib-plot-zooming-with-scroll-wheel
-+ cur_xlim = self.axes.get_xlim()
-+ cur_ylim = self.axes.get_ylim()
-+
-+ xdata = event.xdata
-+ ydata = event.ydata
-+ if event.button == 'up':
-+ scale_factor = 1/self.base_scale
-+ elif event.button == 'down':
-+ scale_factor = self.base_scale
-+ else:
-+ scale_factor = 1
-+
-+ extend = (xdata - (xdata - cur_xlim[0]) * scale_factor,
-+ xdata + (cur_xlim[1] - xdata) * scale_factor,
-+ ydata - (ydata - cur_ylim[0]) * scale_factor,
-+ ydata + (cur_ylim[1] - ydata) * scale_factor)
-+
-+ self.axes.axis(extend)
-+
-+ self.canvas.draw()
-+
-+ def ZoomRectangle(self, event):
-+ # get the current x and y limits
-+ if not self.mode == "zoom": return
-+ if event.inaxes is None: return
-+ if event.button != 1: return
-+
-+ cur_xlim = self.axes.get_xlim()
-+ cur_ylim = self.axes.get_ylim()
-+
-+ x1, y1 = event.xdata, event.ydata
-+ x2 = deepcopy(self.zoom_rect_coords['x'])
-+ y2 = deepcopy(self.zoom_rect_coords['y'])
-+
-+ if x1 == x2 or y1 == y2:
-+ return
-+
-+ self.axes.axis((x1, x2, y1, y2))
-+ #self.axes.set_xlim(x1, x2)#, auto = True)
-+ #self.axes.set_ylim(y1, y2)#, auto = True)
-+ self.canvas.draw()
-+
-+ def Motion(self, event):
-+ self.PanMotion(event)
-+ self.ZoomRectMotion(event)
-+
-+ if event.inaxes is None:
-+ return
-+
-+ self.cursorMove.emit(x=event.xdata, y=event.ydata)
-+
-+ def PanMotion(self, event):
-+ 'on mouse movement'
-+ if not self.mode == "pan":
-+ return
-+ if event.inaxes is None:
-+ return
-+ if event.button != 1:
-+ return
-+
-+ cur_xlim = self.axes.get_xlim()
-+ cur_ylim = self.axes.get_ylim()
-+
-+ x,y = event.xdata, event.ydata
-+
-+ mx = (x - self.zoom_wheel_coords['x']) * 0.6
-+ my = (y - self.zoom_wheel_coords['y']) * 0.6
-+
-+ extend = (cur_xlim[0] - mx, cur_xlim[1] - mx, cur_ylim[0] - my, cur_ylim[1] - my)
-+
-+ self.zoom_wheel_coords['x'] = x
-+ self.zoom_wheel_coords['y'] = y
-+
-+ self.axes.axis(extend)
-+
-+ #self.canvas.copy_from_bbox(self.axes.bbox)
-+ #self.canvas.restore_region(self.background)
-+ self.canvas.draw()
-+
-+ def ZoomRectMotion(self, event):
-+ if not self.mode == "zoom": return
-+ if event.inaxes is None: return
-+ if event.button != 1: return
-+
-+ x1, y1 = event.xdata, event.ydata
-+ self.zoom_rect.set_visible(True)
-+ x2 = self.zoom_rect_coords['x']
-+ y2 = self.zoom_rect_coords['y']
-+
-+ self.zoom_rect.xy = ((x1, y1), (x1, y2), (x2, y2), (x2, y1), (x1, y1))
-+
-+ #self.axes.draw_artist(self.zoom_rect)
-+ self.canvas.draw()
-+
-+class ScatterPlotContextMenu:
-+ def __init__(self, plot):
-+
-+ self.plot = plot
-+ self.canvas = plot.canvas
-+ self.cidpress = self.canvas.mpl_connect(
-+ 'button_press_event', self.ContexMenu)
-+
-+ def ContexMenu(self, event):
-+ if not event.inaxes:
-+ return
-+
-+ if event.button == 3:
-+ menu = wx.Menu()
-+ menu_items = [["zoom_to_extend", _("Zoom to scatter plot extend"), lambda event : self.plot.ZoomToExtend()]]
-+
-+ for item in menu_items:
-+ item_id = wx.ID_ANY
-+ menu.Append(item_id, text = item[1])
-+ menu.Bind(wx.EVT_MENU, item[2], id = item_id)
-+
-+ wx.CallAfter(self.ShowMenu, menu)
-+
-+ def ShowMenu(self, menu):
-+ self.plot.PopupMenu(menu)
-+ menu.Destroy()
-+ self.plot.ReleaseMouse()
-+
-+class PolygonDrawer:
-+ """
-+ An polygon editor.
-+ """
-+ def __init__(self, ax, pol, empty_pol):
-+ if pol.figure is None:
-+ raise RuntimeError('You must first add the polygon to a figure or canvas before defining the interactor')
-+ self.ax = ax
-+ self.canvas = pol.figure.canvas
-+
-+ self.showverts = True
-+
-+ self.pol = pol
-+ self.empty_pol = empty_pol
-+
-+ x, y = zip(*self.pol.xy)
-+
-+ style = self._getPolygonStyle()
-+
-+ self.line = Line2D(x, y, marker='o', markerfacecolor='r', animated=True)
-+ self.ax.add_line(self.line)
-+ #self._update_line(pol)
-+
-+ cid = self.pol.add_callback(self.poly_changed)
-+ self.moving_ver_idx = None # the active vert
-+
-+ self.mode = None
-+
-+ if self.empty_pol:
-+ self._show(False)
-+
-+ #self.canvas.mpl_connect('draw_event', self.draw_callback)
-+ self.canvas.mpl_connect('button_press_event', self.OnButtonPressed)
-+ self.canvas.mpl_connect('button_release_event', self.button_release_callback)
-+ self.canvas.mpl_connect('motion_notify_event', self.motion_notify_callback)
-+
-+ self.it = 0
-+
-+ def _getPolygonStyle(self):
-+ style = {}
-+ style['sel_pol'] = UserSettings.Get(group='scatt',
-+ key='selection',
-+ subkey='sel_pol')
-+ style['sel_pol_vertex'] = UserSettings.Get(group='scatt',
-+ key='selection',
-+ subkey='sel_pol_vertex')
-+
-+ style['sel_pol'] = [i / 255.0 for i in style['sel_pol']]
-+ style['sel_pol_vertex'] = [i / 255.0 for i in style['sel_pol_vertex']]
-+
-+ return style
-+
-+ def _getSnapTresh(self):
-+ return UserSettings.Get(group='scatt',
-+ key='selection',
-+ subkey='snap_tresh')
-+
-+ def SetMode(self, mode):
-+ self.mode = mode
-+
-+ def SetSelectionPolygonMode(self, activate):
-+
-+ self.Show(activate)
-+ if not activate and self.mode:
-+ self.SetMode(None)
-+
-+ def Show(self, show):
-+ if show:
-+ if not self.empty_pol:
-+ self._show(True)
-+ else:
-+ self._show(False)
-+
-+ def GetCoords(self):
-+ if self.empty_pol:
-+ return None
-+
-+ coords = deepcopy(self.pol.xy)
-+ return coords
-+
-+ def SetEmpty(self):
-+ self._setEmptyPol(True)
-+
-+ def _setEmptyPol(self, empty_pol):
-+ self.empty_pol = empty_pol
-+ self._show(not empty_pol)
-+
-+ def _show(self, show):
-+
-+ self.show = show
-+
-+ self.line.set_visible(self.show)
-+ self.pol.set_visible(self.show)
-+
-+ self.Redraw()
-+
-+ def Redraw(self):
-+ if self.show:
-+ self.ax.draw_artist(self.pol)
-+ self.ax.draw_artist(self.line)
-+ self.canvas.blit(self.ax.bbox)
-+ self.canvas.draw()
-+
-+ def draw_callback(self, event):
-+
-+ style=self._getPolygonStyle()
-+ self.pol.set_facecolor(style['sel_pol'])
-+ self.line.set_markerfacecolor(style['sel_pol_vertex'])
-+
-+ self.background = self.canvas.copy_from_bbox(self.ax.bbox)
-+ self.ax.draw_artist(self.pol)
-+ self.ax.draw_artist(self.line)
-+
-+ def poly_changed(self, pol):
-+ 'this method is called whenever the polygon object is called'
-+ # only copy the artist props to the line (except visibility)
-+ vis = self.line.get_visible()
-+ Artist.update_from(self.line, pol)
-+ self.line.set_visible(vis) # don't use the pol visibility state
-+
-+ def get_ind_under_point(self, event):
-+ 'get the index of the vertex under point if within treshold'
-+
-+ # display coords
-+ xy = np.asarray(self.pol.xy)
-+ xyt = self.pol.get_transform().transform(xy)
-+ xt, yt = xyt[:, 0], xyt[:, 1]
-+ d = np.sqrt((xt-event.x)**2 + (yt-event.y)**2)
-+ indseq = np.nonzero(np.equal(d, np.amin(d)))[0]
-+ ind = indseq[0]
-+
-+ if d[ind]>=self._getSnapTresh():
-+ ind = None
-+
-+ return ind
-+
-+ def OnButtonPressed(self, event):
-+ if not event.inaxes:
-+ return
-+
-+ if event.button in [2, 3]:
-+ return
-+
-+ if self.mode == "delete_vertex":
-+ self._deleteVertex(event)
-+ elif self.mode == "add_boundary_vertex":
-+ self._addVertexOnBoundary(event)
-+ elif self.mode == "add_vertex":
-+ self._addVertex(event)
-+ elif self.mode == "remove_polygon":
-+ self.SetEmpty()
-+ self.moving_ver_idx = self.get_ind_under_point(event)
-+
-+ def button_release_callback(self, event):
-+ 'whenever a mouse button is released'
-+ if not self.showverts: return
-+ if event.button != 1: return
-+ self.moving_ver_idx = None
-+
-+ def ShowVertices(self, show):
-+ self.showverts = show
-+ self.line.set_visible(self.showverts)
-+ if not self.showverts: self.moving_ver_idx = None
-+
-+ def _deleteVertex(self, event):
-+ ind = self.get_ind_under_point(event)
-+
-+ if ind is None or self.empty_pol:
-+ return
-+
-+ if len(self.pol.xy) <= 2:
-+ self.empty_pol = True
-+ self._show(False)
-+ return
-+
-+ coords = []
-+ for i,tup in enumerate(self.pol.xy):
-+ if i == ind:
-+ continue
-+ elif i == 0 and ind == len(self.pol.xy) - 1:
-+ continue
-+ elif i == len(self.pol.xy) - 1 and ind == 0:
-+ continue
-+
-+ coords.append(tup)
-+
-+ self.pol.xy = coords
-+ self.line.set_data(zip(*self.pol.xy))
-+
-+ self.Redraw()
-+
-+ def _addVertexOnBoundary(self, event):
-+ if self.empty_pol:
-+ return
-+
-+ xys = self.pol.get_transform().transform(self.pol.xy)
-+ p = event.x, event.y # display coords
-+ for i in range(len(xys)-1):
-+ s0 = xys[i]
-+ s1 = xys[i+1]
-+ d = dist_point_to_segment(p, s0, s1)
-+
-+ if d<=self._getSnapTresh():
-+ self.pol.xy = np.array(
-+ list(self.pol.xy[:i + 1]) +
-+ [(event.xdata, event.ydata)] +
-+ list(self.pol.xy[i + 1:]))
-+ self.line.set_data(zip(*self.pol.xy))
-+ break
-+
-+ self.Redraw()
-+
-+ def _addVertex(self, event):
-+
-+ if self.empty_pol:
-+ pt = (event.xdata, event.ydata)
-+ self.pol.xy = np.array([pt, pt])
-+ self._show(True)
-+ self.empty_pol = False
-+ else:
-+ self.pol.xy = np.array(
-+ [(event.xdata, event.ydata)] +
-+ list(self.pol.xy[1:]) +
-+ [(event.xdata, event.ydata)])
-+
-+ self.line.set_data(zip(*self.pol.xy))
-+
-+ self.Redraw()
-+
-+ def motion_notify_callback(self, event):
-+ 'on mouse movement'
-+ if not self.mode == "move_vertex": return
-+ if not self.showverts: return
-+ if self.empty_pol: return
-+ if self.moving_ver_idx is None: return
-+ if event.inaxes is None: return
-+ if event.button != 1: return
-+
-+ self.it += 1
-+
-+ x,y = event.xdata, event.ydata
-+
-+ self.pol.xy[self.moving_ver_idx] = x,y
-+ if self.moving_ver_idx == 0:
-+ self.pol.xy[len(self.pol.xy) - 1] = x,y
-+ elif self.moving_ver_idx == len(self.pol.xy) - 1:
-+ self.pol.xy[0] = x,y
-+
-+ self.line.set_data(zip(*self.pol.xy))
-+
-+ self.canvas.restore_region(self.background)
-+
-+ self.Redraw()
-+
-+class ModestImage(mi.AxesImage):
-+ """
-+ Computationally modest image class.
-+
-+ ModestImage is an extension of the Matplotlib AxesImage class
-+ better suited for the interactive display of larger images. Before
-+ drawing, ModestImage resamples the data array based on the screen
-+ resolution and view window. This has very little affect on the
-+ appearance of the image, but can substantially cut down on
-+ computation since calculations of unresolved or clipped pixels
-+ are skipped.
-+
-+ The interface of ModestImage is the same as AxesImage. However, it
-+ does not currently support setting the 'extent' property. There
-+ may also be weird coordinate warping operations for images that
-+ I'm not aware of. Don't expect those to work either.
-+
-+ Author: Chris Beaumont <beaumont at hawaii.edu>
-+ """
-+ def __init__(self, minx=0.0, miny=0.0, *args, **kwargs):
-+ if 'extent' in kwargs and kwargs['extent'] is not None:
-+ raise NotImplementedError("ModestImage does not support extents")
-+
-+ self._full_res = None
-+ self._sx, self._sy = None, None
-+ self._bounds = (None, None, None, None)
-+ self.minx = minx
-+ self.miny = miny
-+
-+ super(ModestImage, self).__init__(*args, **kwargs)
-+
-+ def set_data(self, A):
-+ """
-+ Set the image array
-+
-+ ACCEPTS: numpy/PIL Image A
-+ """
-+ self._full_res = A
-+ self._A = A
-+
-+ if self._A.dtype != np.uint8 and not np.can_cast(self._A.dtype,
-+ np.float):
-+ raise TypeError("Image data can not convert to float")
-+
-+ if (self._A.ndim not in (2, 3) or
-+ (self._A.ndim == 3 and self._A.shape[-1] not in (3, 4))):
-+ raise TypeError("Invalid dimensions for image data")
-+
-+ self._imcache =None
-+ self._rgbacache = None
-+ self._oldxslice = None
-+ self._oldyslice = None
-+ self._sx, self._sy = None, None
-+
-+ def get_array(self):
-+ """Override to return the full-resolution array"""
-+ return self._full_res
-+
-+ def _scale_to_res(self):
-+ """ Change self._A and _extent to render an image whose
-+ resolution is matched to the eventual rendering."""
-+
-+ ax = self.axes
-+ ext = ax.transAxes.transform([1, 1]) - ax.transAxes.transform([0, 0])
-+ xlim, ylim = ax.get_xlim(), ax.get_ylim()
-+ dx, dy = xlim[1] - xlim[0], ylim[1] - ylim[0]
-+
-+ y0 = max(self.miny, ylim[0] - 5)
-+ y1 = min(self._full_res.shape[0] + self.miny, ylim[1] + 5)
-+ x0 = max(self.minx, xlim[0] - 5)
-+ x1 = min(self._full_res.shape[1] + self.minx, xlim[1] + 5)
-+ y0, y1, x0, x1 = map(int, [y0, y1, x0, x1])
-+
-+ sy = int(max(1, min((y1 - y0) / 5., np.ceil(dy / ext[1]))))
-+ sx = int(max(1, min((x1 - x0) / 5., np.ceil(dx / ext[0]))))
-+
-+ # have we already calculated what we need?
-+ if sx == self._sx and sy == self._sy and \
-+ x0 == self._bounds[0] and x1 == self._bounds[1] and \
-+ y0 == self._bounds[2] and y1 == self._bounds[3]:
-+ return
-+
-+ self._A = self._full_res[y0 - self.miny:y1 - self.miny:sy,
-+ x0 - self.minx:x1 - self.minx:sx]
-+
-+ x1 = x0 + self._A.shape[1] * sx
-+ y1 = y0 + self._A.shape[0] * sy
-+
-+ self.set_extent([x0 - .5, x1 - .5, y0 - .5, y1 - .5])
-+ self._sx = sx
-+ self._sy = sy
-+ self._bounds = (x0, x1, y0, y1)
-+ self.changed()
-+
-+ def draw(self, renderer, *args, **kwargs):
-+ self._scale_to_res()
-+ super(ModestImage, self).draw(renderer, *args, **kwargs)
-+
-+def imshow(axes, X, cmap=None, norm=None, aspect=None,
-+ interpolation=None, alpha=None, vmin=None, vmax=None,
-+ origin=None, extent=None, shape=None, filternorm=1,
-+ filterrad=4.0, imlim=None, resample=None, url=None, **kwargs):
-+ """Similar to matplotlib's imshow command, but produces a ModestImage
-+
-+ Unlike matplotlib version, must explicitly specify axes
-+ Author: Chris Beaumont <beaumont at hawaii.edu>
-+ """
-+
-+ if not axes._hold:
-+ axes.cla()
-+ if norm is not None:
-+ assert(isinstance(norm, mcolors.Normalize))
-+ if aspect is None:
-+ aspect = rcParams['image.aspect']
-+ axes.set_aspect(aspect)
-+
-+ if extent:
-+ minx=extent[0]
-+ miny=extent[2]
-+ else:
-+ minx=0.0
-+ miny=0.0
-+
-+ im = ModestImage(minx, miny, axes, cmap, norm, interpolation, origin, extent,
-+ filternorm=filternorm,
-+ filterrad=filterrad, resample=resample, **kwargs)
-+
-+ im.set_data(X)
-+ im.set_alpha(alpha)
-+ axes._set_artist_props(im)
-+
-+ if im.get_clip_path() is None:
-+ # image does not already have clipping set, clip to axes patch
-+ im.set_clip_path(axes.patch)
-+
-+ #if norm is None and shape is None:
-+ # im.set_clim(vmin, vmax)
-+ if vmin is not None or vmax is not None:
-+ im.set_clim(vmin, vmax)
-+ else:
-+ im.autoscale_None()
-+ im.set_url(url)
-+
-+ # update ax.dataLim, and, if autoscaling, set viewLim
-+ # to tightly fit the image, regardless of dataLim.
-+ im.set_extent(im.get_extent())
-+
-+ axes.images.append(im)
-+ im._remove_method = lambda h: axes.images.remove(h)
-+
-+ return im
-+
-+def MergeImg(cats_order, scatts, styles, output_queue):
-+
-+ start_time = time.clock()
-+ cmap_time = 0
-+ merge_time = 0
-+ mask_time = 0
-+ norm_time = 0
-+ max_time = 0
-+
-+ init = True
-+ merge_tmp = grass.tempfile()
-+ for cat_id in cats_order:
-+ if not scatts.has_key(cat_id):
-+ continue
-+ scatt = scatts[cat_id]
-+ #print "color map %d" % cat_id
-+ #TODO make more general
-+ if cat_id != 0 and (styles[cat_id]['opacity'] == 0.0 or \
-+ not styles[cat_id]['show']):
-+ continue
-+ if init:
-+
-+ b2_i = scatt['bands_info']['b1']
-+ b1_i = scatt['bands_info']['b2']
-+
-+ full_extend = (b1_i['min'] - 0.5, b1_i['max'] + 0.5, b2_i['min'] - 0.5, b2_i['max'] + 0.5)
-+
-+ if cat_id == 0:
-+ cmap = matplotlib.cm.jet
-+ cmap.set_bad('w',1.)
-+ cmap._init()
-+ cmap._lut[len(cmap._lut) - 1, -1] = 0
-+ else:
-+ colors = styles[cat_id]['color'].split(":")
-+
-+ cmap = matplotlib.cm.jet
-+ cmap.set_bad('w',1.)
-+ cmap._init()
-+ cmap._lut[len(cmap._lut) - 1, -1] = 0
-+ cmap._lut[:, 0] = int(colors[0])/255.0
-+ cmap._lut[:, 1] = int(colors[1])/255.0
-+ cmap._lut[:, 2] = int(colors[2])/255.0
-+
-+ #if init:
-+ tmp = time.clock()
-+
-+ masked_cat = np.ma.masked_less_equal(scatt['np_vals'], 0)
-+ mask_time += time.clock() - tmp
-+
-+ tmp = time.clock()
-+ vmax = np.amax(masked_cat)
-+ max_time += time.clock() - tmp
-+
-+ tmp = time.clock()
-+ masked_cat = np.uint8(masked_cat * (255.0 / float(vmax)))
-+ norm_time += time.clock() - tmp
-+
-+ #print masked_cat
-+ #print masked_cat.shape
-+ #print masked_cat.mask.dtype
-+ #
-+ #print "colored_cat.shape"
-+ #print colored_cat.shape
-+ #merged_img = np.memmap(merge_tmp, dtype='uint8',, shape=colored_cat.shape)
-+ tmp = time.clock()
-+ cmap = np.uint8(cmap._lut * 255)
-+ sh =masked_cat.shape
-+
-+ colored_cat = np.zeros(dtype='uint8', shape=(sh[0], sh[1], 4))
-+ ApplyColormap(masked_cat, masked_cat.mask, cmap, colored_cat)
-+
-+ #colored_cat = np.uint8(cmap(masked_cat) * 255)
-+ cmap_time += time.clock() - tmp
-+
-+ del masked_cat
-+ del cmap
-+
-+ #colored_cat[...,3] = np.choose(masked_cat.mask, (255, 0))
-+
-+ tmp = time.clock()
-+ if init:
-+ merged_img = np.memmap(merge_tmp, dtype='uint8', mode='w+', shape=colored_cat.shape)
-+ merged_img[:] = colored_cat[:]
-+ init = False
-+ else:
-+ MergeArrays(merged_img, colored_cat, styles[cat_id]['opacity'])
-+
-+ """
-+ #c_img_a = np.memmap(grass.tempfile(), dtype="uint16", mode='w+', shape = shape)
-+ c_img_a = colored_cat.astype('uint16')[:,:,3] * styles[cat_id]['opacity']
-+
-+ #TODO apply strides and there will be no need for loop
-+ #b = as_strided(a, strides=(0, a.strides[3], a.strides[3], a.strides[3]), shape=(3, a.shape[0], a.shape[1]))
-+
-+ for i in range(3):
-+ merged_img[:,:,i] = (merged_img[:,:,i] * (255 - c_img_a) + colored_cat[:,:,i] * c_img_a) / 255;
-+ merged_img[:,:,3] = (merged_img[:,:,3] * (255 - c_img_a) + 255 * c_img_a) / 255;
-+
-+ del c_img_a
-+ """
-+ merge_time += time.clock() - tmp
-+
-+ del colored_cat
-+
-+ end_time = time.clock() - start_time
-+ #print "all time:%f" % (end_time)
-+ #print "cmap_time:%f" % (cmap_time / end_time * 100.0 )
-+ #print "merge_time:%f" % (merge_time / end_time * 100.0 )
-+ #print "mask_time:%f" % (mask_time / end_time * 100.0 )
-+ #print "nax_time:%f" % (max_time / end_time * 100.0 )
-+ #print "norm_time:%f" % (norm_time / end_time * 100.0 )
-+
-+ #output_queue.put((merged_img, full_extend))
-+ return merged_img, full_extend
-\ No newline at end of file
-Index: gui/wxpython/mapdisp/toolbars.py
-===================================================================
---- gui/wxpython/mapdisp/toolbars.py (revision 57734)
-+++ gui/wxpython/mapdisp/toolbars.py (working copy)
-@@ -49,6 +49,8 @@
- label = _('Create histogram of raster map')),
- 'vnet' : MetaIcon(img = 'vector-tools',
- label = _('Vector network analysis tool')),
-+ 'interact_scatter' : MetaIcon(img = 'layer-raster-profile',
-+ label = _("Interactive scatter plot tool")),
- }
-
- NvizIcons = {
-@@ -239,7 +241,9 @@
- (MapIcons["scatter"], self.parent.OnScatterplot),
- (MapIcons["histogram"], self.parent.OnHistogramPyPlot),
- (BaseIcons["histogramD"], self.parent.OnHistogram),
-- (MapIcons["vnet"], self.parent.OnVNet)))
-+ (MapIcons["vnet"], self.parent.OnVNet),
-+ (MapIcons["interact_scatter"],
-+ self.parent.OnIScatt)))
-
- def OnDecoration(self, event):
- """!Decorations overlay menu
-Index: gui/wxpython/mapdisp/frame.py
-===================================================================
---- gui/wxpython/mapdisp/frame.py (revision 57734)
-+++ gui/wxpython/mapdisp/frame.py (working copy)
-@@ -225,6 +225,7 @@
- #
- self.dialogs = {}
- self.dialogs['attributes'] = None
-+ self.dialogs['scatt_plot'] = None
- self.dialogs['category'] = None
- self.dialogs['barscale'] = None
- self.dialogs['legend'] = None
-@@ -1168,6 +1169,19 @@
- """!Returns toolbar with zooming tools"""
- return self.toolbars['map']
-
-+ def OnIScatt(self, event):
-+ """!Init interactive scatterplot tools
-+ """
-+ if self.dialogs['scatt_plot']:
-+ self.dialogs['scatt_plot'].Raise()
-+ return
-+
-+ from scatt_plot.frame import IScattDialog
-+ self.dialogs['scatt_plot'] = IScattDialog(parent=self, giface=self._giface)
-+
-+ self.dialogs['scatt_plot'].CenterOnScreen()
-+ self.dialogs['scatt_plot'].Show()
-+
- def OnVNet(self, event):
- """!Dialog for v.net* modules
- """
-Index: gui/wxpython/vdigit/wxdigit.py
-===================================================================
---- gui/wxpython/vdigit/wxdigit.py (revision 57734)
-+++ gui/wxpython/vdigit/wxdigit.py (working copy)
-@@ -17,7 +17,7 @@
- (and NumPy would be an excellent candidate for acceleration via
- e.g. OpenCL or CUDA; I'm surprised it hasn't happened already).
-
--(C) 2007-2011 by the GRASS Development Team
-+(C) 2007-2011, 2013 by the GRASS Development Team
-
- This program is free software under the GNU General Public License
- (>=v2). Read the file COPYING that comes with GRASS for details.
-@@ -27,6 +27,8 @@
-
- import grass.script.core as grass
-
-+from grass.pydispatch.signal import Signal
-+
- from core.gcmd import GError
- from core.debug import Debug
- from core.settings import UserSettings
-@@ -176,7 +178,21 @@
-
- if self.poMapInfo:
- self.InitCats()
--
-+
-+ self.emit_signals = False
-+
-+ # signals which describes features changes during digitization,
-+ # activate them using EmitSignals method
-+ #TODO signal for errors?
-+ self.featureAdded = Signal('IVDigit.featureAdded')
-+ self.areasDeleted = Signal('IVDigit.areasDeleted')
-+ self.vertexMoved = Signal('IVDigit.vertexMoved')
-+ self.vertexAdded = Signal('IVDigit.vertexAdded')
-+ self.vertexRemoved = Signal('IVDigit.vertexRemoved')
-+ self.featuresDeleted = Signal('IVDigit.featuresDeleted')
-+ self.featuresMoved = Signal('IVDigit.featuresMoved')
-+ self.lineEdited = Signal('IVDigit.lineEdited')
-+
- def __del__(self):
- Debug.msg(1, "IVDigit.__del__()")
- Vect_destroy_line_struct(self.poPoints)
-@@ -188,7 +204,12 @@
- Vect_close(self.poBgMapInfo)
- self.poBgMapInfo = self.popoBgMapInfo = None
- del self.bgMapInfo
--
-+
-+ def EmitSignals(self, emit):
-+ """!Activate/deactivate signals which describes features changes during digitization.
-+ """
-+ self.emit_signals = emit
-+
- def CloseBackgroundMap(self):
- """!Close background vector map"""
- if not self.poBgMapInfo:
-@@ -394,7 +415,6 @@
-
- @return tuple (number of added features, feature ids)
- """
--
- layer = self._getNewFeaturesLayer()
- cat = self._getNewFeaturesCat()
-
-@@ -419,10 +439,14 @@
- return (-1, None)
-
- self.toolbar.EnableUndo()
--
-- return self._addFeature(vtype, points, layer, cat,
-- self._getSnapMode(), self._display.GetThreshold())
--
-+
-+ ret = self._addFeature(vtype, points, layer, cat,
-+ self._getSnapMode(), self._display.GetThreshold())
-+ if ret[0] > -1 and self.emit_signals:
-+ self.featureAdded.emit(new_bboxs = [self._createBbox(points)], new_areas_cats = [[{layer : [cat]}, None]])
-+
-+ return ret
-+
- def DeleteSelectedLines(self):
- """!Delete selected features
-
-@@ -434,16 +458,27 @@
- # collect categories for deleting if requested
- deleteRec = UserSettings.Get(group = 'vdigit', key = 'delRecord', subkey = 'enabled')
- catDict = dict()
-+
-+ old_bboxs = []
-+ old_areas_cats = []
- if deleteRec:
- for i in self._display.selected['ids']:
-+
- if Vect_read_line(self.poMapInfo, None, self.poCats, i) < 0:
- self._error.ReadLine(i)
-
-- cats = self.poCats.contents
-- for j in range(cats.n_cats):
-- if cats.field[j] not in catDict.keys():
-- catDict[cats.field[j]] = list()
-- catDict[cats.field[j]].append(cats.cat[j])
-+ if self.emit_signals:
-+ ret = self._getLineAreaBboxCats(i)
-+ if ret:
-+ old_bboxs += ret[0]
-+ old_areas_cats += ret[1]
-+
-+ # catDict was not used -> put into comment
-+ #cats = self.poCats.contents
-+ #for j in range(cats.n_cats):
-+ # if cats.field[j] not in catDict.keys():
-+ # catDict[cats.field[j]] = list()
-+ # catDict[cats.field[j]].append(cats.cat[j])
-
- poList = self._display.GetSelectedIList()
- nlines = Vedit_delete_lines(self.poMapInfo, poList)
-@@ -456,7 +491,10 @@
- self._deleteRecords(catDict)
- self._addChangeset()
- self.toolbar.EnableUndo()
--
-+
-+ if self.emit_signals:
-+ self.featuresDeleted.emit(old_bboxs = old_bboxs, old_areas_cats = old_areas_cats)
-+
- return nlines
-
- def _deleteRecords(self, cats):
-@@ -512,22 +550,173 @@
-
- @return number of deleted
- """
-+ if len(self._display.selected['ids']) < 1:
-+ return 0
-+
- poList = self._display.GetSelectedIList()
- cList = poList.contents
-
- nareas = 0
-+ old_bboxs = []
-+ old_areas_cats = []
-+
- for i in range(cList.n_values):
-+
- if Vect_get_line_type(self.poMapInfo, cList.value[i]) != GV_CENTROID:
- continue
--
-+
-+ if self.emit_signals:
-+ area = Vect_get_centroid_area(self.poMapInfo, cList.value[i]);
-+ if area > 0:
-+ bbox, cats = self._getaAreaBboxCats(area)
-+ old_bboxs += bbox
-+ old_areas_cats += cats
-+
- nareas += Vedit_delete_area_centroid(self.poMapInfo, cList.value[i])
-
- if nareas > 0:
- self._addChangeset()
- self.toolbar.EnableUndo()
-+ if self.emit_signals:
-+ self.areasDeleted.emit(old_bboxs = old_bboxs, old_areas_cats = old_areas_cats)
-+
-+ return nareas
-+
-+ def _getLineAreaBboxCats(self, ln_id):
-+ ltype = Vect_read_line(self.poMapInfo, None, None, ln_id)
-+
-+ if ltype == GV_CENTROID:
-+ #TODO centroid opttimization, can be adited also its area -> it will appear two times in new_ lists
-+ return self._getCentroidAreaBboxCats(ln_id)
-+ else:
-+ return [self._getBbox(ln_id)], [self._getLineAreasCategories(ln_id)]
-+
-+
-+ def _getCentroidAreaBboxCats(self, centroid):
-+ if not Vect_line_alive(self.poMapInfo, centroid):
-+ return None
-+
-+ area = Vect_get_centroid_area(self.poMapInfo, centroid)
-+ if area > 0:
-+ return self._getaAreaBboxCats(area)
-+ else:
-+ return None
-+
-+ def _getaAreaBboxCats(self, area):
-+
-+ po_b_list = Vect_new_list()
-+ Vect_get_area_boundaries(self.poMapInfo, area, po_b_list);
-+ b_list = po_b_list.contents
-+
-+ geoms = []
-+ areas_cats = []
-+
-+ if b_list.n_values > 0:
-+ for i_line in range(b_list.n_values):
-+
-+ line = b_list.value[i_line];
-+
-+ geoms.append(self._getBbox(abs(line)))
-+ areas_cats.append(self._getLineAreasCategories(abs(line)))
-
-- return nareas
-+ Vect_destroy_list(po_b_list);
-+
-+ return geoms, areas_cats
-+
-+ def _getLineAreasCategories(self, ln_id):
-+ if not Vect_line_alive (self.poMapInfo, ln_id):
-+ return []
-+
-+ ltype = Vect_read_line(self.poMapInfo, None, None, ln_id)
-+ if ltype != GV_BOUNDARY:
-+ return []
-+
-+ cats = [None, None]
-+
-+ left = c_int()
-+ right = c_int()
-+
-+ if Vect_get_line_areas(self.poMapInfo, ln_id, pointer(left), pointer(right)) == 1:
-+ areas = [left.value, right.value]
-+
-+ for i, a in enumerate(areas):
-+ if a > 0:
-+ centroid = Vect_get_area_centroid(self.poMapInfo, a)
-+ if centroid <= 0:
-+ continue
-+ c = self._getCategories(centroid)
-+ if c:
-+ cats[i] = c
-+
-+ return cats
-+
-+ def _getCategories(self, ln_id):
-+ if not Vect_line_alive (self.poMapInfo, ln_id):
-+ return none
-+
-+ poCats = Vect_new_cats_struct()
-+ if Vect_read_line(self.poMapInfo, None, poCats, ln_id) < 0:
-+ Vect_destroy_cats_struct(poCats)
-+ return None
-+
-+ cCats = poCats.contents
-+
-+ cats = {}
-+ for j in range(cCats.n_cats):
-+ if cats.has_key(cCats.field[j]):
-+ cats[cCats.field[j]].append(cCats.cat[j])
-+ else:
-+ cats[cCats.field[j]] = [cCats.cat[j]]
-
-+ Vect_destroy_cats_struct(poCats)
-+ return cats
-+
-+ def _getBbox(self, ln_id):
-+ if not Vect_line_alive (self.poMapInfo, ln_id):
-+ return None
-+
-+ poPoints = Vect_new_line_struct()
-+ if Vect_read_line(self.poMapInfo, poPoints, None, ln_id) < 0:
-+ Vect_destroy_line_struct(poPoints)
-+ return []
-+
-+ geom = self._convertGeom(poPoints)
-+ bbox = self._createBbox(geom)
-+ Vect_destroy_line_struct(poPoints)
-+ return bbox
-+
-+ def _createBbox(self, points):
-+
-+ bbox = {}
-+ for pt in points:
-+ if not bbox.has_key('maxy'):
-+ bbox['maxy'] = pt[1]
-+ bbox['miny'] = pt[1]
-+ bbox['maxx'] = pt[0]
-+ bbox['minx'] = pt[0]
-+ continue
-+
-+ if bbox['maxy'] < pt[1]:
-+ bbox['maxy'] = pt[1]
-+ elif bbox['miny'] > pt[1]:
-+ bbox['miny'] = pt[1]
-+
-+ if bbox['maxx'] < pt[0]:
-+ bbox['maxx'] = pt[0]
-+ elif bbox['minx'] > pt[0]:
-+ bbox['minx'] = pt[0]
-+ return bbox
-+
-+ def _convertGeom(self, poPoints):
-+
-+ Points = poPoints.contents
-+
-+ pts_geom = []
-+ for j in range(Points.n_points):
-+ pts_geom.append((Points.x[j], Points.y[j]))
-+
-+ return pts_geom
-+
- def MoveSelectedLines(self, move):
- """!Move selected features
-
-@@ -536,16 +725,45 @@
- if not self._checkMap():
- return -1
-
-+ nsel = len(self._display.selected['ids'])
-+ if nsel < 1:
-+ return -1
-+
- thresh = self._display.GetThreshold()
- snap = self._getSnapMode()
-
- poList = self._display.GetSelectedIList()
-+
-+ if self.emit_signals:
-+ old_bboxs = []
-+ old_areas_cats = []
-+ for sel_id in self._display.selected['ids']:
-+ ret = self._getLineAreaBboxCats(sel_id)
-+ if ret:
-+ old_bboxs += ret[0]
-+ old_areas_cats += ret[1]
-+
-+ Vect_set_updated(self.poMapInfo, 1)
-+ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
-+
- nlines = Vedit_move_lines(self.poMapInfo, self.popoBgMapInfo, int(self.poBgMapInfo is not None),
- poList,
- move[0], move[1], 0,
- snap, thresh)
-+
- Vect_destroy_list(poList)
--
-+
-+ if nlines > 0 and self.emit_signals:
-+ new_bboxs = []
-+ new_areas_cats = []
-+ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
-+ for i in range(n_up_lines_old, n_up_lines):
-+ new_id = Vect_get_updated_line(self.poMapInfo, i)
-+ ret = self._getLineAreaBboxCats(new_id)
-+ if ret:
-+ new_bboxs += ret[0]
-+ new_areas_cats += ret[1]
-+
- if nlines > 0 and self._settings['breakLines']:
- for i in range(1, nlines):
- self._breakLineAtIntersection(nlines + i, None, changeset)
-@@ -553,7 +771,13 @@
- if nlines > 0:
- self._addChangeset()
- self.toolbar.EnableUndo()
--
-+
-+ if self.emit_signals:
-+ self.featuresMoved.emit(new_bboxs = new_bboxs,
-+ old_bboxs = old_bboxs,
-+ old_areas_cats = old_areas_cats,
-+ new_areas_cats = new_areas_cats)
-+
- return nlines
-
- def MoveSelectedVertex(self, point, move):
-@@ -571,12 +795,21 @@
-
- if len(self._display.selected['ids']) != 1:
- return -1
--
-+
-+ # move only first found vertex in bbox
-+ poList = self._display.GetSelectedIList()
-+
-+ if self.emit_signals:
-+ cList = poList.contents
-+ old_bboxs = [self._getBbox(cList.value[0])]
-+ old_areas_cats = [self._getLineAreasCategories(cList.value[0])]
-+
-+ Vect_set_updated(self.poMapInfo, 1)
-+ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
-+
- Vect_reset_line(self.poPoints)
- Vect_append_point(self.poPoints, point[0], point[1], 0.0)
--
-- # move only first found vertex in bbox
-- poList = self._display.GetSelectedIList()
-+
- moved = Vedit_move_vertex(self.poMapInfo, self.popoBgMapInfo, int(self.poBgMapInfo is not None),
- poList, self.poPoints,
- self._display.GetThreshold(type = 'selectThresh'),
-@@ -584,7 +817,17 @@
- move[0], move[1], 0.0,
- 1, self._getSnapMode())
- Vect_destroy_list(poList)
--
-+
-+ if moved > 0 and self.emit_signals:
-+ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
-+
-+ new_bboxs = []
-+ new_areas_cats = []
-+ for i in range(n_up_lines_old, n_up_lines):
-+ new_id = Vect_get_updated_line(self.poMapInfo, i)
-+ new_bboxs.append(self._getBbox(new_id))
-+ new_areas_cats.append(self._getLineAreasCategories(new_id))
-+
- if moved > 0 and self._settings['breakLines']:
- self._breakLineAtIntersection(Vect_get_num_lines(self.poMapInfo),
- None)
-@@ -592,7 +835,13 @@
- if moved > 0:
- self._addChangeset()
- self.toolbar.EnableUndo()
--
-+
-+ if self.emit_signals:
-+ self.vertexMoved.emit(new_bboxs = new_bboxs,
-+ new_areas_cats = new_areas_cats,
-+ old_areas_cats = old_areas_cats,
-+ old_bboxs = old_bboxs)
-+
- return moved
-
- def AddVertex(self, coords):
-@@ -681,6 +930,10 @@
- self._error.ReadLine(line)
- return -1
-
-+ if self.emit_signals:
-+ old_bboxs = [self._getBbox(line)]
-+ old_areas_cats = [self._getLineAreasCategories(line)]
-+
- # build feature geometry
- Vect_reset_line(self.poPoints)
- for p in coords:
-@@ -696,6 +949,9 @@
-
- newline = Vect_rewrite_line(self.poMapInfo, line, ltype,
- self.poPoints, self.poCats)
-+ if newline > 0 and self.emit_signals:
-+ new_geom = [self._getBbox(newline)]
-+ new_areas_cats = [self._getLineAreasCategories(newline)]
-
- if newline > 0 and self._settings['breakLines']:
- self._breakLineAtIntersection(newline, None)
-@@ -703,7 +959,13 @@
- if newline > 0:
- self._addChangeset()
- self.toolbar.EnableUndo()
--
-+
-+ if self.emit_signals:
-+ self.lineEdited.emit(old_bboxs = old_bboxs,
-+ old_areas_cats = old_areas_cats,
-+ new_bboxs = new_bboxs,
-+ new_areas_cats = new_areas_cats)
-+
- return newline
-
- def FlipLine(self):
-@@ -1514,6 +1776,16 @@
- return 0
-
- poList = self._display.GetSelectedIList()
-+
-+ if self.emit_signals:
-+ cList = poList.contents
-+
-+ old_bboxs = [self._getBbox(cList.value[0])]
-+ old_areas_cats = [self._getLineAreasCategories(cList.value[0])]
-+
-+ Vect_set_updated(self.poMapInfo, 1)
-+ n_up_lines_old = Vect_get_num_updated_lines(self.poMapInfo)
-+
- Vect_reset_line(self.poPoints)
- Vect_append_point(self.poPoints, coords[0], coords[1], 0.0)
-
-@@ -1525,15 +1797,35 @@
- else:
- ret = Vedit_remove_vertex(self.poMapInfo, poList,
- self.poPoints, thresh)
-+
- Vect_destroy_list(poList)
-+
-+ if ret > 0 and self.emit_signals:
-+ new_bboxs = []
-+ new_areas_cats = []
-+
-+ n_up_lines = Vect_get_num_updated_lines(self.poMapInfo)
-+ for i in range(n_up_lines_old, n_up_lines):
-+ new_id = Vect_get_updated_line(self.poMapInfo, i)
-+ new_areas_cats.append(self._getLineAreasCategories(new_id))
-+ new_bboxs.append(self._getBbox(new_id))
-
- if not add and ret > 0 and self._settings['breakLines']:
- self._breakLineAtIntersection(Vect_get_num_lines(self.poMapInfo),
- None)
--
-+
- if ret > 0:
- self._addChangeset()
--
-+
-+ if ret > 0 and self.emit_signals:
-+ if add:
-+ self.vertexAdded.emit(old_bboxs = old_bboxs, new_bboxs = new_bboxs)
-+ else:
-+ self.vertexRemoved.emit(old_bboxs = old_bboxs,
-+ new_bboxs = new_bboxs,
-+ old_areas_cats = old_areas_cats,
-+ new_areas_cats = new_areas_cats)
-+
- return 1
-
- def GetLineCats(self, line):
-Index: gui/wxpython/vdigit/toolbars.py
-===================================================================
---- gui/wxpython/vdigit/toolbars.py (revision 57734)
-+++ gui/wxpython/vdigit/toolbars.py (working copy)
-@@ -17,6 +17,7 @@
- import wx
-
- from grass.script import core as grass
-+from grass.pydispatch.signal import Signal
-
- from gui_core.toolbars import BaseToolbar, BaseIcons
- from gui_core.dialogs import CreateNewVector
-@@ -42,6 +43,8 @@
- self.digit = None
- self._giface = giface
-
-+ self.editingStarted = Signal("VDigitToolbar.editingStarted")
-+
- # currently selected map layer for editing (reference to MapLayer instance)
- self.mapLayer = None
- # list of vector layers from Layer Manager (only in the current mapset)
-@@ -860,6 +863,7 @@
- alpha = int(opacity * 255)
- self.digit.GetDisplay().UpdateSettings(alpha = alpha)
-
-+ self.editingStarted.emit(vectMap = mapLayer.GetName(), digit = self.digit)
- return True
-
- def StopEditing(self):
-Index: gui/icons/grass/polygon.png
-===================================================================
-Cannot display: file marked as a binary type.
-svn:mime-type = application/octet-stream
-Index: gui/icons/grass/polygon.png
-===================================================================
---- gui/icons/grass/polygon.png (revision 57734)
-+++ gui/icons/grass/polygon.png (working copy)
-
-Property changes on: gui/icons/grass/polygon.png
-___________________________________________________________________
-Added: svn:mime-type
-## -0,0 +1 ##
-+application/octet-stream
-\ No newline at end of property
-Index: lib/imagery/scatt_sccats.c
-===================================================================
---- lib/imagery/scatt_sccats.c (revision 0)
-+++ lib/imagery/scatt_sccats.c (working copy)
-@@ -0,0 +1,405 @@
-+/*!
-+ \file lib/imagery/scatt_cat_rast.c
-+
-+ \brief Imagery library - functions for manipulation with scatter plot structs.
-+
-+ Copyright (C) 2013 by the GRASS Development Team
-+
-+ This program is free software under the GNU General Public License
-+ (>=v2). Read the file COPYING that comes with GRASS for details.
-+
-+ \author Stepan Turek <stepan.turek at seznam.cz> (Mentor: Martin Landa)
-+ */
-+
-+#include <grass/raster.h>
-+#include <grass/imagery.h>
-+#include <grass/gis.h>
-+
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <math.h>
-+#include <string.h>
-+
-+/*!
-+ \brief Compute band ids from scatter plot id.
-+
-+ Scatter plot id describes which bands defines the scatter plot.
-+
-+ Let say we have 3 bands, their ids are 0, 1 and 2.
-+ Scatter plot with id 0 consists of band 1 (b_1_id) 0 and band 2 (b_2_id) 1.
-+ All scatter plots:
-+ scatt_id b_1_id b_2_id
-+ 0 0 1
-+ 1 0 2
-+ 2 1 2
-+
-+ \param scatt_id scatter plot id
-+ \param n_bands number of bands
-+ \param [out] b_1_id id of band1
-+ \param[out] b_2_id id of band2
-+
-+ \return 0
-+ */
-+int I_id_scatt_to_bands(const int scatt_id, const int n_bands, int * b_1_id, int * b_2_id)
-+{
-+ int n_b1 = n_bands - 1;
-+
-+ * b_1_id = (int) ((2 * n_b1 + 1 - sqrt((double)((2 * n_b1 + 1) * (2 * n_b1 + 1) - 8 * scatt_id))) / 2);
-+
-+ * b_2_id = scatt_id - ((* b_1_id) * (2 * n_b1 + 1) - (* b_1_id) * (* b_1_id)) / 2 + (* b_1_id) + 1;
-+
-+ return 0;
-+}
-+
-+
-+/*!
-+ \brief Compute scatter plot id from band ids.
-+
-+ See also I_id_scatt_to_bands().
-+
-+ \param n_bands number of bands
-+ \param b_1_id id of band1
-+ \param b_1_id id of band2
-+ \param [out] scatt_id scatter plot id
-+
-+ \return 0
-+ */
-+int I_bands_to_id_scatt(const int b_1_id, const int b_2_id, const int n_bands, int * scatt_id)
-+{
-+ int n_b1 = n_bands - 1;
-+
-+ * scatt_id = (b_1_id * (2 * n_b1 + 1) - b_1_id * b_1_id) / 2 + b_2_id - b_1_id - 1;
-+
-+ return 0;
-+}
-+
-+/*!
-+ \brief Initialize structure for storing scatter plots data.
-+
-+ \param cats pointer to scCats struct
-+ \param n_bands number of bands
-+ \param type SC_SCATT_DATA - stores scatter plots
-+ \param type SC_SCATT_CONDITIONS - stores selected areas in scatter plots
-+ */
-+void I_sc_init_cats(struct scCats * cats, int n_bands, int type)
-+{
-+ int i_cat;
-+
-+ cats->type = type;
-+
-+ cats->n_cats = 100;
-+ cats->n_a_cats = 0;
-+
-+ cats->n_bands = n_bands;
-+ cats->n_scatts = (n_bands - 1) * n_bands / 2;
-+
-+ cats->cats_arr = (struct scScatts **) G_malloc(cats->n_cats * sizeof(struct scScatts *));
-+ memset(cats->cats_arr, 0, cats-> n_cats * sizeof(struct scScatts *));
-+
-+ cats->cats_ids = (int *) G_malloc(cats->n_cats * sizeof(int));
-+ cats->cats_idxs =(int *) G_malloc(cats->n_cats * sizeof(int));
-+
-+ for(i_cat = 0; i_cat < cats->n_cats; i_cat++)
-+ cats->cats_idxs[i_cat] = -1;
-+
-+ return;
-+}
-+
-+/*!
-+ \brief Free data of struct scCats, the structure itself remains alocated.
-+
-+ \param cats pointer to existing scCats struct
-+ */
-+void I_sc_free_cats(struct scCats * cats)
-+{
-+ int i_cat;
-+
-+ for(i_cat = 0; i_cat < cats->n_a_cats; i_cat++)
-+ {
-+ if(cats->cats_arr[i_cat])
-+ {
-+ G_free(cats->cats_arr[i_cat]->scatt_idxs);
-+ G_free(cats->cats_arr[i_cat]->scatts_bands);
-+ G_free(cats->cats_arr[i_cat]->scatts_arr);
-+ G_free(cats->cats_arr[i_cat]);
-+ }
-+ }
-+
-+ G_free(cats->cats_ids);
-+ G_free(cats->cats_idxs);
-+ G_free(cats->cats_arr);
-+
-+ cats->n_cats = 0;
-+ cats->n_a_cats = 0;
-+ cats->n_bands = 0;
-+ cats->n_scatts = 0;
-+ cats->type = -1;
-+
-+ return;
-+}
-+
-+#if 0
-+void I_sc_get_active_categories(int * a_cats_ids, int * n_a_cats, struct scCats * cats)
-+{
-+ a_cats_ids = cats->cats_ids;
-+ * n_a_cats = cats->n_a_cats;
-+}
-+#endif
-+
-+/*!
-+ \brief Add category.
-+
-+ Category represents group of scatter plots.
-+
-+ \param cats pointer to scCats struct
-+
-+ \return assigned category id (starts with 0)
-+ \return -1 if maximum nuber of categories was reached
-+ */
-+int I_sc_add_cat(struct scCats * cats)
-+{
-+ int i_scatt, i_cat_id, cat_id;
-+ int n_a_cats = cats->n_a_cats;
-+
-+ if(cats->n_a_cats >= cats->n_cats)
-+ return -1;
-+
-+ for(i_cat_id = 0; i_cat_id < cats->n_cats; i_cat_id++)
-+ if(cats->cats_idxs[i_cat_id] < 0) {
-+ cat_id = i_cat_id;
-+ break;
-+ }
-+
-+ cats->cats_ids[n_a_cats] = cat_id;
-+ cats->cats_idxs[cat_id] = n_a_cats;
-+
-+ cats->cats_arr[n_a_cats] = (struct scScatts *) G_malloc(sizeof(struct scScatts));
-+
-+ cats->cats_arr[n_a_cats]->scatts_arr = (struct scdScattData **) G_malloc(cats->n_scatts * sizeof(struct scdScattData *));
-+ memset((cats->cats_arr[n_a_cats]->scatts_arr), 0, cats->n_scatts * sizeof(struct scdScattData *));
-+
-+ cats->cats_arr[n_a_cats]->n_a_scatts = 0;
-+
-+ cats->cats_arr[n_a_cats]->scatts_bands = (int *) G_malloc(cats->n_scatts * 2 * sizeof(int));
-+
-+ cats->cats_arr[n_a_cats]->scatt_idxs = (int *) G_malloc(cats->n_scatts * sizeof(int));
-+ for(i_scatt = 0; i_scatt < cats->n_scatts; i_scatt++)
-+ cats->cats_arr[n_a_cats]->scatt_idxs[i_scatt] = -1;
-+
-+ ++cats->n_a_cats;
-+
-+ return cat_id;
-+}
-+
-+#if 0
-+int I_sc_delete_cat(struct scCats * cats, int cat_id)
-+{
-+ int cat_idx, i_cat;
-+
-+ if(cat_id < 0 || cat_id >= cats->n_cats)
-+ return -1;
-+
-+ cat_idx = cats->cats_idxs[cat_id];
-+ if(cat_idx < 0)
-+ return -1;
-+
-+ G_free(cats->cats_arr[cat_idx]->scatt_idxs);
-+ G_free(cats->cats_arr[cat_idx]->scatts_bands);
-+ G_free(cats->cats_arr[cat_idx]->scatts_arr);
-+ G_free(cats->cats_arr[cat_idx]);
-+
-+ for(i_cat = cat_idx; i_cat < cats->n_a_cats - 1; i_cat++)
-+ {
-+ cats->cats_arr[i_cat] = cats->cats_arr[i_cat + 1];
-+ cats->cats_ids[i_cat] = cats->cats_ids[i_cat + 1];
-+ }
-+ cats->cats_idxs[cat_id] = -1;
-+
-+ --cats->n_a_cats;
-+
-+ return 0;
-+}
-+#endif
-+
-+/*!
-+ \brief Insert scatter plot data .
-+ Inserted scatt_data struct must have same type as cats struct (SC_SCATT_DATA or SC_SCATT_CONDITIONS).
-+
-+ \param cats pointer to scCats struct
-+ \param cat_id id number of category.
-+ \param scatt_id id number of scatter plot.
-+
-+ \return 0 on success
-+ \return -1 on failure
-+ */
-+int I_sc_insert_scatt_data(struct scCats * cats, struct scdScattData * scatt_data, int cat_id, int scatt_id)
-+{
-+ int band_1, band_2, cat_idx, n_a_scatts;
-+ struct scScatts * scatts;
-+
-+ if(cat_id < 0 || cat_id >= cats->n_cats)
-+ return -1;
-+
-+ cat_idx = cats->cats_idxs[cat_id];
-+ if(cat_idx < 0)
-+ return -1;
-+
-+ if(scatt_id < 0 && scatt_id >= cats->n_scatts)
-+ return -1;
-+
-+ scatts = cats->cats_arr[cat_idx];
-+ if(scatts->scatt_idxs[scatt_id] >= 0)
-+ return -1;
-+
-+ if(!scatt_data->b_conds_arr && cats->type == SC_SCATT_CONDITIONS)
-+ return -1;
-+
-+ if(!scatt_data->scatt_vals_arr && cats->type == SC_SCATT_DATA)
-+ return -1;
-+
-+ n_a_scatts = scatts->n_a_scatts;
-+
-+ scatts->scatt_idxs[scatt_id] = n_a_scatts;
-+
-+ I_id_scatt_to_bands(scatt_id, cats->n_bands, &band_1, &band_2);
-+
-+ scatts->scatts_bands[n_a_scatts * 2] = band_1;
-+ scatts->scatts_bands[n_a_scatts * 2 + 1] = band_2;
-+
-+ scatts->scatts_arr[n_a_scatts] = scatt_data;
-+ ++scatts->n_a_scatts;
-+
-+ return 0;
-+}
-+
-+#if 0
-+int I_sc_remove_scatt_data(struct scCats * cats, struct scdScattData * scatt_data, int cat_id, int scatt_id)
-+{
-+ int cat_idx, scatt_idx, n_init_scatts, i_scatt;
-+ struct scScatts * scatts;
-+
-+ if(cat_id < 0 && cat_id >= cats->n_cats)
-+ return -1;
-+
-+ cat_idx = cats->cats_idxs[cat_id];
-+ if(cat_idx < 0)
-+ return -1;
-+
-+ if(scatt_id < 0 || scatt_id >= cats->n_scatts)
-+ return -1;
-+
-+ scatts = cats->cats_arr[cat_idx];
-+ if(scatts->scatt_idxs[scatt_id] < 0)
-+ return -1;
-+
-+ scatt_data = scatts->scatts_arr[scatt_idx];
-+
-+ for(i_scatt = scatt_idx; i_scatt < scatts->n_a_scatts - 1; i_scatt++)
-+ {
-+ scatts->scatts_arr[i_scatt] = scatts->scatts_arr[i_scatt + 1];
-+ scatts->scatts_bands[i_scatt * 2] = scatts->scatts_bands[(i_scatt + 1)* 2];
-+ scatts->scatts_bands[i_scatt * 2 + 1] = scatts->scatts_bands[(i_scatt + 1) * 2 + 1];
-+ }
-+ scatts->scatts_arr[scatts->n_a_scatts] = NULL;
-+
-+ scatts->scatt_idxs[scatt_id] = -1;
-+
-+ scatt_data = scatts->scatts_arr[scatt_id];
-+ scatts->n_a_scatts--;
-+
-+ return 0;
-+}
-+
-+int I_sc_set_value(struct scCats * cats, int cat_id, int scatt_id, int value_idx, int value)
-+{
-+ int n_a_scatts = cats->cats_arr[cat_id]->n_a_scatts;
-+ int cat_idx, scatt_idx, ret;
-+
-+ cat_idx = cats->cats_idxs[cat_id];
-+ if(cat_idx < 0)
-+ return -1;
-+
-+ if(cats->cats_arr[cat_idx]->scatt_idxs[scatt_id] < 0)
-+ return -1;
-+
-+ cat_idx = cats->cats_idxs[cat_id];
-+ scatt_idx = cats->cats_arr[cat_idx]->scatt_idxs[scatt_id];
-+
-+ I_scd_set_value(cats->cats_arr[cat_idx]->scatts_arr[scatt_idx], value_idx, value);
-+
-+ return 0;
-+}
-+#endif
-+
-+/*!
-+ \brief Insert scatter plot data.
-+
-+ \param scatt_data pointer to existing struct scdScattData
-+ \param type SC_SCATT_DATA for scatter plots or SC_SCATT_CONDITIONS for selected areas in scatter plot
-+ \param n_vals number of data values
-+ \param data array of values (unsigned char for SC_SCATT_CONDITIONS, unsigned int for SC_SCATT_DATA)
-+ */
-+void I_scd_init_scatt_data(struct scdScattData * scatt_data, int type, int n_vals, void * data)
-+{
-+ scatt_data->n_vals = n_vals;
-+
-+ if(type == SC_SCATT_DATA)
-+ {
-+ if(data)
-+ scatt_data->scatt_vals_arr = (unsigned int *) data;
-+ else {
-+ scatt_data->scatt_vals_arr = (unsigned int *) G_malloc(n_vals * sizeof(unsigned int));
-+ memset(scatt_data->scatt_vals_arr, 0, n_vals * sizeof(unsigned int));
-+ }
-+ scatt_data->b_conds_arr = NULL;
-+ }
-+ else if(type == SC_SCATT_CONDITIONS)
-+ {
-+ if(data)
-+ scatt_data->b_conds_arr = (unsigned char *) data;
-+ else {
-+ scatt_data->b_conds_arr = (unsigned char *) G_malloc(n_vals * sizeof(unsigned char));
-+ memset(scatt_data->b_conds_arr, 0, n_vals * sizeof(unsigned char));
-+ }
-+ scatt_data->scatt_vals_arr = NULL;
-+ }
-+
-+ return;
-+}
-+
-+
-+#if 0
-+void I_scd_get_range_min_max(struct scdScattData * scatt_data, CELL * band_1_min, CELL * band_1_max, CELL * band_2_min, CELL * band_2_max)
-+{
-+
-+ Rast_get_range_min_max(&(scatt_data->band_1_range), band_1_min, band_2_min);
-+ Rast_get_range_min_max(&(scatt_data->band_2_range), band_2_min, band_2_max);
-+
-+ return;
-+}
-+s
-+void * I_scd_get_data_ptr(struct scdScattData * scatt_data)
-+{
-+ if(!scatt_data->b_conds_arr)
-+ return scatt_data->b_conds_arr;
-+ else if(!scatt_data->scatt_vals_arr)
-+ return scatt_data->scatt_vals_arr;
-+
-+ return NULL;
-+}
-+
-+int I_scd_set_value(struct scdScattData * scatt_data, unsigned int val_idx, unsigned int val)
-+{
-+ if(val_idx < 0 && val_idx > scatt_data->n_vals)
-+ return -1;
-+
-+ if(scatt_data->b_conds_arr)
-+ scatt_data->b_conds_arr[val_idx] = val;
-+ else if(scatt_data->scatt_vals_arr)
-+ scatt_data->scatt_vals_arr[val_idx] = val;
-+ else
-+ return -1;
-+
-+ return 0;
-+}
-+#endif
-Index: lib/imagery/scatt.c
-===================================================================
---- lib/imagery/scatt.c (revision 0)
-+++ lib/imagery/scatt.c (working copy)
-@@ -0,0 +1,871 @@
-+/*!
-+ \file lib/imagery/scatt.c
-+
-+ \brief Imagery library - functions for wx Scatter Plot Tool.
-+
-+ Low level functions used by wx Scatter Plot Tool.
-+
-+ Copyright (C) 2013 by the GRASS Development Team
-+
-+ This program is free software under the GNU General Public License
-+ (>=v2). Read the file COPYING that comes with GRASS for details.
-+
-+ \author Stepan Turek <stepan.turek at seznam.cz> (Mentor: Martin Landa)
-+ */
-+#include <stdio.h>
-+#include <stdlib.h>
-+#include <math.h>
-+#include <string.h>
-+
-+#include <grass/gis.h>
-+#include <grass/vector.h>
-+#include <grass/raster.h>
-+#include <grass/imagery.h>
-+#include <grass/glocale.h>
-+
-+#include "iclass_local_proto.h"
-+
-+struct rast_row
-+{
-+ CELL * row;
-+ char * null_row;
-+ struct Range rast_range; /*Range of whole raster.*/
-+};
-+
-+/*!
-+ \brief Create pgm header.
-+
-+ Scatter plot internally generates pgm files. These pgms have header in format created by this function.
-+
-+ \param region region to be pgm header generated for
-+ \param [out] header header of pgm file
-+ */
-+static int get_cat_rast_header(struct Cell_head * region, char * header){
-+ return sprintf(header, "P5\n%d\n%d\n1\n", region->cols, region->rows);
-+}
-+
-+/*!
-+ \brief Create category raster conditions file.
-+
-+ \param cat_rast_region region to be file generated for
-+ \param cat_rast path of generated category raster file
-+ */
-+int I_create_cat_rast(struct Cell_head * cat_rast_region, const char * cat_rast)
-+{
-+ FILE * f_cat_rast;
-+ char cat_rast_header[1024];//TODO magic number
-+ int i_row, i_col;
-+ int head_nchars;
-+
-+ unsigned char * row_data;
-+
-+ f_cat_rast = fopen(cat_rast, "wb");
-+ if(!f_cat_rast) {
-+ G_warning("Unable to create category raster condition file <%s>.", cat_rast);
-+ return -1;
-+ }
-+
-+ head_nchars = get_cat_rast_header(cat_rast_region, cat_rast_header);
-+
-+ fwrite(cat_rast_header, sizeof(char), head_nchars/sizeof(char), f_cat_rast);
-+ if (ferror(f_cat_rast)){
-+ fclose(f_cat_rast);
-+ G_warning(_("Unable to write header into category raster condition file <%s>."), cat_rast);
-+ return -1;
-+ }
-+
-+ row_data = (unsigned char *) G_malloc(cat_rast_region->cols * sizeof(unsigned char));
-+ for(i_col = 0; i_col < cat_rast_region->cols; i_col++)
-+ row_data[i_col] = 0 & 255;
-+
-+ for(i_row = 0; i_row < cat_rast_region->rows; i_row++) {
-+ fwrite(row_data, sizeof(unsigned char), (cat_rast_region->cols)/sizeof(unsigned char), f_cat_rast);
-+ if (ferror(f_cat_rast))
-+ {
-+ fclose(f_cat_rast);
-+ G_warning(_("Unable to write into category raster condition file <%s>."), cat_rast);
-+ return -1;
-+ }
-+ }
-+
-+ fclose(f_cat_rast);
-+ return 0;
-+}
-+
-+static int print_reg(struct Cell_head * intersec, const char * pref, int dbg_level)
-+{
-+ G_debug(dbg_level, "%s:\n n:%f\ns:%f\ne:%f\nw:%f\nns_res:%f\new_res:%f", pref, intersec->north, intersec->south,
-+ intersec->east, intersec->west, intersec->ns_res, intersec->ew_res);
-+}
-+
-+/*!
-+ \brief Find intersection region of two regions.
-+
-+ \param A pointer to intersected region
-+ \param B pointer to intersected region
-+ \param [out] intersec pointer to intersection region of regions A B (relevant params of the region are: south, north, east, west)
-+
-+ \return 0 if interection exists
-+ \return -1 if regions does not intersect
-+ */
-+static int regions_intersecion(struct Cell_head * A, struct Cell_head * B, struct Cell_head * intersec)
-+{
-+
-+ if(B->north < A->south) return -1;
-+ else if(B->north > A->north) intersec->north = A->north;
-+ else intersec->north = B->north;
-+
-+ if(B->south > A->north) return -1;
-+ else if(B->south < A->south) intersec->south = A->south;
-+ else intersec->south = B->south;
-+
-+ if(B->east < A->west) return -1;
-+ else if(B->east > A->east) intersec->east = A->east;
-+ else intersec->east = B->east;
-+
-+ if(B->west > A->east) return -1;
-+ else if(B->west < A->west) intersec->west = A->west;
-+ else intersec->west = B->west;
-+
-+ if(intersec->north == intersec->south) return -1;
-+
-+ if(intersec->east == intersec->west) return -1;
-+
-+ return 0;
-+
-+}
-+
-+/*!
-+ \brief Get rows and cols numbers, which defines intersection of the regions.
-+
-+ \param A pointer to intersected region
-+ \param B pointer to intersected region (A and B must have same resolution)
-+ \param [out] A_bounds rows and cols numbers of A stored in south, north, east, west, which defines intersection of A and B
-+ \param [out] B_bounds rows and cols numbers of B stored in south, north, east, west, which defines intersection of A and B
-+
-+ \return 0 if interection exists
-+ \return -1 if regions do not intersect
-+ \return -2 resolution of regions is not same
-+*/
-+static int get_rows_and_cols_bounds(struct Cell_head * A, struct Cell_head * B, struct Cell_head * A_bounds, struct Cell_head * B_bounds)
-+{
-+ float ns_res, ew_res;
-+
-+ struct Cell_head intersec;
-+
-+ /* TODO is it right check? */
-+ if(abs(A->ns_res - B->ns_res) > GRASS_EPSILON) {
-+ G_debug(0, "'get_rows_and_cols_bounds' ns_res does not fit, A->ns_res: %f B->ns_res: %f", A->ns_res, B->ns_res);
-+ return -2;
-+ }
-+
-+ if(abs(A->ew_res - B->ew_res) > GRASS_EPSILON) {
-+ G_debug(0, "'get_rows_and_cols_bounds' ew_res does not fit, A->ew_res: %f B->ew_res: %f", A->ew_res, B->ew_res);
-+ return -2;
-+ }
-+
-+ ns_res = A->ns_res;
-+ ew_res = A->ew_res;
-+
-+ if(regions_intersecion(A, B, &intersec) == -1)
-+ return -1;
-+
-+ A_bounds->north = ceil((A->north - intersec.north - ns_res * 0.5) / ns_res);
-+ A_bounds->south = ceil((A->north - intersec.south - ns_res * 0.5) / ns_res);
-+
-+ A_bounds->east = ceil((intersec.east - A->west - ew_res * 0.5) / ew_res);
-+ A_bounds->west = ceil((intersec.west - A->west - ew_res * 0.5) / ew_res);
-+
-+ B_bounds->north = ceil((B->north - intersec.north - ns_res * 0.5) / ns_res);
-+ B_bounds->south = ceil((B->north - intersec.south - ns_res * 0.5) / ns_res);
-+
-+ B_bounds->east = ceil((intersec.east - B->west - ew_res * 0.5) / ew_res);
-+ B_bounds->west = ceil((intersec.west - B->west - ew_res * 0.5) / ew_res);
-+
-+ return 0;
-+}
-+
-+/*!
-+ \brief Insert raster map patch into pgm file.
-+ Warning: calls Rast_set_window
-+
-+ \param patch_rast name of raster map
-+ \param cat_rast_region region of category raster file
-+ \param cat_rast path to category raster file
-+
-+ \return 0 on success
-+ \return -1 on failure
-+*/
-+int I_insert_patch_to_cat_rast(const char * patch_rast, struct Cell_head * cat_rast_region, const char * cat_rast)
-+{
-+
-+ FILE * f_cat_rast;
-+ struct Cell_head patch_region, patch_bounds, cat_rast_bounds;
-+ char cat_rast_header[1024];//TODO magic number
-+ int i_row, i_col, ncols, nrows, cat_rast_col, patch_col, val;
-+ int head_nchars, ret;
-+ int fd_patch_rast, init_shift, step_shift;
-+ unsigned char * patch_data;
-+
-+ char * null_chunk_row;
-+
-+ const char *mapset;
-+
-+ struct Cell_head patch_lines, cat_rast_lines;
-+
-+ unsigned char * row_data;
-+
-+ f_cat_rast = fopen(cat_rast, "rb+");
-+ if(!f_cat_rast) {
-+ G_warning(_("Unable to open category raster condtions file <%s>."), cat_rast);
-+ return -1;
-+ }
-+
-+ head_nchars = get_cat_rast_header(cat_rast_region, cat_rast_header);
-+ if ((mapset = G_find_raster(patch_rast,"")) == NULL) {
-+ fclose(f_cat_rast);
-+ G_warning(_("Unable to find patch raster <%s>."), patch_rast);
-+ return -1;
-+ }
-+
-+ Rast_get_cellhd(patch_rast, mapset, &patch_region);
-+ Rast_set_window(&patch_region);
-+
-+ if ((fd_patch_rast = Rast_open_old(patch_rast, mapset)) < 0) {
-+ fclose(f_cat_rast);
-+ return -1;
-+ }
-+
-+ ret = get_rows_and_cols_bounds(cat_rast_region, &patch_region, &cat_rast_bounds, &patch_bounds);
-+ if(ret == -2) {
-+ G_warning(_("Resolutions of patch <%s> and patched file <%s> are not same."), patch_rast, cat_rast);
-+
-+ Rast_close(fd_patch_rast);
-+ fclose(f_cat_rast);
-+
-+ return -1;
-+ }
-+ else if (ret == -1){
-+
-+ Rast_close(fd_patch_rast);
-+ fclose(f_cat_rast);
-+
-+ return 0;
-+ }
-+
-+ ncols = cat_rast_bounds.east - cat_rast_bounds.west;
-+ nrows = cat_rast_bounds.south - cat_rast_bounds.north;
-+
-+ patch_data = (unsigned char *) G_malloc(ncols * sizeof(unsigned char));
-+
-+ init_shift = head_nchars + cat_rast_region->cols * cat_rast_bounds.north + cat_rast_bounds.west;
-+
-+ if(fseek(f_cat_rast, init_shift, SEEK_SET) != 0) {
-+ G_warning(_("Corrupted category raster conditions file <%s> (fseek failed)"), cat_rast);
-+
-+ Rast_close(fd_patch_rast);
-+ G_free(null_chunk_row);
-+ fclose(f_cat_rast);
-+
-+ return -1;
-+ }
-+
-+ step_shift = cat_rast_region->cols - ncols;
-+
-+ null_chunk_row = Rast_allocate_null_buf();
-+
-+ for(i_row = 0; i_row < nrows; i_row++) {
-+ Rast_get_null_value_row (fd_patch_rast, null_chunk_row, i_row + patch_bounds.north);
-+
-+ for(i_col = 0; i_col < ncols; i_col++) {
-+ patch_col = patch_bounds.west + i_col;
-+
-+ if(null_chunk_row[patch_col] != 1)
-+ patch_data[i_col] = 1 & 255;
-+ else {
-+ patch_data[i_col] = 0 & 255;
-+ }
-+ }
-+
-+ fwrite(patch_data, sizeof(unsigned char), (ncols)/sizeof(unsigned char), f_cat_rast);
-+ if (ferror(f_cat_rast))
-+ {
-+ G_warning(_("Unable to write into category raster conditions file <%s>"), cat_rast);
-+
-+ Rast_close(fd_patch_rast);
-+ G_free(null_chunk_row);
-+ fclose(f_cat_rast);
-+
-+ return -1;
-+ }
-+ if(fseek(f_cat_rast, step_shift, SEEK_CUR) != 0) {
-+ G_warning(_("Corrupted category raster conditions file <%s> (fseek failed)"), cat_rast);
-+
-+ Rast_close(fd_patch_rast);
-+ G_free(null_chunk_row);
-+ fclose(f_cat_rast);
-+
-+ return -1;
-+ }
-+ }
-+
-+ Rast_close(fd_patch_rast);
-+ G_free(null_chunk_row);
-+ fclose(f_cat_rast);
-+ return 0;
-+}
-+
-+/*!
-+ \brief Updates scatter plots data in category by pixels which meets category conditions.
-+
-+ \param bands_rows data represents data describig one row from raster band
-+ \param belongs_pix array which defines which pixels belongs to category (1 value) and which not (0 value)
-+ \param [out] scatts pointer to scScatts struct of type SC_SCATT_DATA, which are modified according to values in belongs_pix
-+*/
-+static inline void update_cat_scatt_plts(struct rast_row * bands_rows, unsigned short * belongs_pix, struct scScatts * scatts)
-+{
-+ int band_axis_1, band_axis_2, i_scatt, array_idx, cat_idx, i_chunk_rows_pix, max_arr_idx;
-+
-+ CELL * b_1_row;
-+ CELL * b_2_row;
-+ char * b_1_null_row,* b_2_null_row;
-+ struct rast_row b_1_rast_row, b_2_rast_row;
-+
-+ struct Range b_1_range, b_2_range;
-+ int b_1_range_size;
-+
-+ int row_size = Rast_window_cols();
-+
-+ int * scatts_bands = scatts->scatts_bands;
-+
-+ for(i_scatt = 0; i_scatt < scatts->n_a_scatts; i_scatt++)
-+ {
-+ b_1_rast_row = bands_rows[scatts_bands[i_scatt * 2]];
-+ b_2_rast_row = bands_rows[scatts_bands[i_scatt * 2 + 1]];
-+
-+ b_1_row = b_1_rast_row.row;
-+ b_2_row = b_2_rast_row.row;
-+
-+ b_1_null_row = b_1_rast_row.null_row;
-+ b_2_null_row = b_2_rast_row.null_row;
-+
-+ b_1_range = b_1_rast_row.rast_range;
-+ b_2_range = b_2_rast_row.rast_range;
-+
-+ b_1_range_size = b_1_range.max - b_1_range.min + 1;
-+ max_arr_idx = (b_1_range.max - b_1_range.min + 1) * (b_2_range.max - b_2_range.min + 1);
-+
-+ for(i_chunk_rows_pix = 0; i_chunk_rows_pix < row_size; i_chunk_rows_pix++)
-+ {
-+ /* pixel does not belongs to scatter plot or has null value in one of the bands */
-+ if(!belongs_pix[i_chunk_rows_pix] ||
-+ b_1_null_row[i_chunk_rows_pix] == 1 ||
-+ b_2_null_row[i_chunk_rows_pix] == 1)
-+ continue;
-+
-+ /* index in scatter plot array */
-+ array_idx = b_1_row[i_chunk_rows_pix] - b_1_range.min + (b_2_row[i_chunk_rows_pix] - b_2_range.min) * b_1_range_size;
-+
-+ if(array_idx < 0 || array_idx >= max_arr_idx) {
-+ G_warning ("Data inconsistent. Value computed for scatter plot is out of initialized range.");
-+ continue;
-+ }
-+
-+ /* increment scatter plot value */
-+ ++scatts->scatts_arr[i_scatt]->scatt_vals_arr[array_idx];
-+ }
-+ }
-+}
-+
-+/*!
-+ \brief Computes scatter plots data from chunk_rows.
-+
-+ \param scatts pointer to scScatts struct of type SC_SCATT_DATA, where are computed scatter plots stored
-+ \param scatt_conds pointer to scScatts struct of type SC_SCATT_CONDITIONS, where are selected areas (condtitions)stored
-+
-+ \param chunk_rows data arrays of chunk_rows from analyzed raster bands (all data in chunk_rows, null_chunk_rows and belongs_pix arrays represents same region)
-+ \param null_chunk_rows null data arrays of chunk_rows from analyzed raster bands
-+ \param row_size size of data in chunk_rows, null_chunk_rows and belongs_pix arrays
-+ \param f_cats_rasts_conds file which stores selected areas (conditions) from mapwindow see I_create_cat_rast() and I_pa
-+ \param fd_cats_rasts array of openedraster maps which represents all selected pixels for category
-+ \param region analysis region
-+
-+ \return 0 on success
-+ \return -1 on failure
-+*/
-+static inline int compute_scatts_from_chunk_row(struct Cell_head *region, struct scCats * scatt_conds,
-+ FILE ** f_cats_rasts_conds, struct rast_row * bands_rows,
-+ struct scCats * scatts, int * fd_cats_rasts)
-+{
-+
-+ int i_rows_pix, i_cat, i_scatt, n_a_scatts, n_pixs;
-+ int cat_id, scatt_plts_cat_idx, array_idx, max_arr_idx;
-+ char * b_1_null_row,* b_2_null_row;
-+ struct rast_row b_1_rast_row, b_2_rast_row;
-+ CELL * cat_rast_row;
-+
-+ struct scScatts * scatts_conds;
-+ struct scScatts * scatts_scatt_plts;
-+ struct scdScattData * conds;
-+
-+ struct Range b_1_range, b_2_range;
-+ int b_1_range_size;
-+
-+ int * scatts_bands;
-+ struct scdScattData ** scatts_arr;
-+
-+ CELL * b_1_row;
-+ CELL * b_2_row;
-+ unsigned char * i_scatt_conds;
-+
-+ int row_size = Rast_window_cols();
-+
-+ unsigned short * belongs_pix = (unsigned short *) G_malloc(row_size * sizeof(unsigned short));
-+ unsigned char * rast_pixs = (unsigned char *) G_malloc(row_size * sizeof(unsigned char));
-+ cat_rast_row = Rast_allocate_c_buf();
-+
-+
-+ for(i_cat = 0; i_cat < scatt_conds->n_a_cats; i_cat++)
-+ {
-+ scatts_conds = scatt_conds->cats_arr[i_cat];
-+
-+ cat_id = scatt_conds->cats_ids[i_cat];
-+
-+ scatt_plts_cat_idx = scatts->cats_idxs[cat_id];
-+ if(scatt_plts_cat_idx < 0)
-+ continue;
-+ scatts_scatt_plts = scatts->cats_arr[scatt_plts_cat_idx];
-+
-+ G_zero(belongs_pix, row_size * sizeof(unsigned short));
-+
-+ /* if category has no conditions defined, scatter plots without any constraint are computed (default scatter plots) */
-+ if(!scatts_conds->n_a_scatts && !f_cats_rasts_conds[i_cat]) {
-+ for(i_scatt = 0; i_scatt < scatts_scatt_plts->n_a_scatts; i_scatt++)
-+ {
-+ /* all pixels belongs */
-+ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
-+ belongs_pix[i_rows_pix] = 1;
-+ }
-+ }
-+ /* compute belonging pixels for defined conditions */
-+ else
-+ {
-+ scatts_bands = scatts_conds->scatts_bands;
-+
-+ /* check conditions from category raster condtitions file */
-+ if(f_cats_rasts_conds[i_cat]) {
-+ n_pixs = fread(rast_pixs, sizeof(unsigned char), (row_size)/sizeof(unsigned char), f_cats_rasts_conds[i_cat]);
-+
-+ if (ferror(f_cats_rasts_conds[i_cat]))
-+ {
-+ G_free(rast_pixs);
-+ G_free(belongs_pix);
-+ G_warning(_("Unable to read from category raster condtition file."));
-+ return -1;
-+ }
-+ if (n_pixs != n_pixs) {
-+ G_free(rast_pixs);
-+ G_free(belongs_pix);
-+ G_warning(_("Invalid size of category raster conditions file."));
-+ return -1;
-+
-+ }
-+
-+ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
-+ {
-+ if(rast_pixs[i_rows_pix] != 0 & 255)
-+ belongs_pix[i_rows_pix] = 1;
-+ }
-+ }
-+
-+ /* check condtions defined in scatter plots*/
-+ for(i_scatt = 0; i_scatt < scatts_conds->n_a_scatts; i_scatt++)
-+ {
-+ b_1_rast_row = bands_rows[scatts_bands[i_scatt * 2]];
-+ b_2_rast_row = bands_rows[scatts_bands[i_scatt * 2 + 1]];
-+
-+ b_1_row = b_1_rast_row.row;
-+ b_2_row = b_2_rast_row.row;
-+
-+ b_1_null_row = b_1_rast_row.null_row;
-+ b_2_null_row = b_2_rast_row.null_row;
-+
-+ b_1_range = b_1_rast_row.rast_range;
-+ b_2_range = b_2_rast_row.rast_range;
-+
-+ b_1_range_size = b_1_range.max - b_1_range.min + 1;
-+ max_arr_idx = (b_1_range.max - b_1_range.min + 1) * (b_2_range.max - b_2_range.min + 1);
-+
-+ i_scatt_conds = scatts_conds->scatts_arr[i_scatt]->b_conds_arr;
-+
-+ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
-+ {
-+ /* pixels already belongs to category from category raster conditions file or contains null value in one of the bands */
-+ if(belongs_pix[i_rows_pix] ||
-+ b_1_null_row[i_rows_pix] == 1 ||
-+ b_2_null_row[i_rows_pix] == 1)
-+ continue;
-+
-+ array_idx = b_1_row[i_rows_pix] - b_1_range.min + (b_2_row[i_rows_pix] - b_2_range.min) * b_1_range_size;
-+ if(array_idx < 0 || array_idx >= max_arr_idx) {
-+ G_warning ("Data inconsistent. Value computed for scatter plot is out of initialized range.");
-+ continue;
-+ }
-+ /* pixels meets condtion defined in scatter plot */
-+ if(i_scatt_conds[array_idx])
-+ belongs_pix[i_rows_pix] = 1;
-+ }
-+ }
-+ }
-+
-+ /* update category raster with belonging pixels */
-+ if(fd_cats_rasts[i_cat] >= 0) {
-+ Rast_set_null_value(cat_rast_row, Rast_window_cols(), CELL_TYPE);
-+
-+ for(i_rows_pix = 0; i_rows_pix < row_size; i_rows_pix++)
-+ if(belongs_pix[i_rows_pix])
-+ cat_rast_row[i_rows_pix] = belongs_pix[i_rows_pix];
-+
-+ Rast_put_c_row (fd_cats_rasts[i_cat], cat_rast_row);
-+ }
-+
-+ /* update scatter plots with belonging pixels */
-+ update_cat_scatt_plts(bands_rows, belongs_pix, scatts_scatt_plts);
-+ }
-+
-+ G_free(cat_rast_row);
-+ G_free(rast_pixs);
-+ G_free(belongs_pix);
-+
-+ return 0;
-+}
-+
-+/*!
-+ \brief Get list if bands needed to be opened for analysis from scCats struct.
-+*/
-+static void get_needed_bands(struct scCats * cats, int * b_needed_bands)
-+{
-+ // results in b_needed_bands - array of bools - if item has value 1, band (defined by item index) is needed to be opened
-+ int i_cat, i_scatt, cat_id;
-+
-+ for(i_cat = 0; i_cat < cats->n_a_cats; i_cat++)
-+ {
-+ for(i_scatt = 0; i_scatt < cats->cats_arr[i_cat]->n_a_scatts; i_scatt++)
-+ {
-+ G_debug(3, "Active scatt %d in catt %d", i_scatt, i_cat);
-+
-+ b_needed_bands[cats->cats_arr[i_cat]->scatts_bands[i_scatt * 2]] = 1;
-+ b_needed_bands[cats->cats_arr[i_cat]->scatts_bands[i_scatt * 2 + 1]] = 1;
-+ }
-+ }
-+ return;
-+}
-+
-+/*!
-+ \brief Helper function for clean up.
-+*/
-+static void free_compute_scatts_data(int * fd_bands, struct rast_row * bands_rows, int n_a_bands, int * bands_ids,
-+ int * fd_cats_rasts, FILE ** f_cats_rasts_conds, int n_a_cats)
-+{
-+ int i, band_id;
-+
-+ for(i = 0; i < n_a_bands; i++)
-+ {
-+ band_id = bands_ids[i];
-+ if(band_id >= 0) {
-+ Rast_close(fd_bands[i]);
-+ G_free(bands_rows[band_id].row);
-+ G_free(bands_rows[band_id].null_row);
-+ }
-+ }
-+
-+ if(f_cats_rasts_conds)
-+ for(i = 0; i < n_a_cats; i++)
-+ if(f_cats_rasts_conds[i])
-+ fclose(f_cats_rasts_conds[i]);
-+
-+ if(fd_cats_rasts)
-+ for(i = 0; i < n_a_cats; i++)
-+ if(fd_cats_rasts[i] >= 0)
-+ Rast_close(fd_cats_rasts[i]);
-+
-+}
-+
-+/*!
-+ \brief Compute scatter plots data.
-+
-+ If category has not defined no category raster condition file and no scatter plot with consdtion,
-+ default scatter plot is computed.
-+ Warning: calls Rast_set_window
-+
-+ \param region analysis region, beaware that all input data must be prepared for this region (bands (their ranges), cats_rasts_conds rasters...)
-+ \param region function calls Rast_set_window for this region
-+ \param scatt_conds pointer to scScatts struct of type SC_SCATT_CONDITIONS, where are stored selected areas (conditions) in scatter plots
-+ \param cats_rasts_conds paths to category raster conditions files representing selected areas (conditions) in rasters for every category
-+ \param cats_rasts_conds index in array represents corresponding category id
-+ \param cats_rasts_conds for manupulation with category raster conditions file see also I_id_scatt_to_bands() and I_insert_patch_to_cat_rast()
-+ \param bands names of analyzed bands, order of bands is defined by their id
-+ \param n_bands number of bands
-+ \param [out] scatts pointer to scScatts struct of type SC_SCATT_DATA, where are computed scatter plots stored
-+ \param [out] cats_rasts array of raster maps names where will be stored all selected pixels for every category
-+
-+ \return 0 on success
-+ \return -1 on failure
-+*/
-+int I_compute_scatts(struct Cell_head *region, struct scCats * scatt_conds, const char ** cats_rasts_conds,
-+ const char ** bands, int n_bands, struct scCats * scatts, const char ** cats_rasts)
-+{
-+ const char *mapset;
-+ char header[1024];
-+
-+ int fd_cats_rasts[scatt_conds->n_a_cats];
-+ FILE * f_cats_rasts_conds[scatt_conds->n_a_cats];
-+
-+ struct rast_row bands_rows[n_bands];
-+
-+ RASTER_MAP_TYPE data_type;
-+
-+ int nrows, i_band, n_a_bands, band_id,
-+ i, i_row, head_nchars, i_cat, id_cat;
-+
-+ int fd_bands[n_bands];
-+ int bands_ids[n_bands];
-+ int b_needed_bands[n_bands];
-+
-+ Rast_set_window(region);
-+
-+ for(i_band = 0; i_band < n_bands; i_band++)
-+ fd_bands[i_band] = -1;
-+
-+ for(i_band = 0; i_band < n_bands; i_band++)
-+ bands_ids[i_band] = -1;
-+
-+ if (n_bands != scatts->n_bands ||
-+ n_bands != scatt_conds->n_bands)
-+ return -1;
-+
-+ memset(b_needed_bands, 0, (size_t)n_bands * sizeof(int));
-+
-+ get_needed_bands(scatt_conds, &b_needed_bands[0]);
-+ get_needed_bands(scatts, &b_needed_bands[0]);
-+
-+ n_a_bands = 0;
-+
-+ /* open band rasters, which are needed for computation */
-+ for(band_id = 0; band_id < n_bands; band_id++)
-+ {
-+ if(b_needed_bands[band_id])
-+ {
-+ G_debug(3, "Opening raster no. %d with name: %s", band_id, bands[band_id]);
-+
-+ if ((mapset = G_find_raster2(bands[band_id],"")) == NULL) {
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
-+ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
-+ G_warning(_("Unbale to read find raster <%s>"), bands[band_id]);
-+ return -1;
-+ }
-+
-+ if ((fd_bands[n_a_bands] = Rast_open_old(bands[band_id], mapset)) < 0) {
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
-+ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
-+ G_warning(_("Unbale to open raster <%s>"), bands[band_id]);
-+ return -1;
-+ }
-+
-+ data_type = Rast_get_map_type(fd_bands[n_a_bands]);
-+ if(data_type != CELL_TYPE) {
-+ G_warning(_("Raster <%s> type is not <%s>"), bands[band_id], "CELL");
-+ return -1;
-+ }
-+
-+ bands_rows[band_id].row = Rast_allocate_c_buf();
-+ bands_rows[band_id].null_row = Rast_allocate_null_buf();
-+
-+ if(Rast_read_range(bands[band_id], mapset, &bands_rows[band_id].rast_range) != 1){
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands,
-+ bands_ids, NULL, NULL, scatt_conds->n_a_cats);
-+ G_warning(_("Unable to read range of raster <%s>"), bands[band_id]);
-+ return -1;
-+ }
-+
-+ bands_ids[n_a_bands] = band_id;
-+ ++n_a_bands;
-+ }
-+ }
-+
-+ /* open category rasters condition files and category rasters */
-+ for(i_cat = 0; i_cat < scatts->n_a_cats; i_cat++)
-+ {
-+ id_cat = scatts->cats_ids[i_cat];
-+ if(cats_rasts[id_cat]) {
-+ fd_cats_rasts[i_cat] = Rast_open_new(cats_rasts[id_cat], CELL_TYPE);
-+ }
-+ else
-+ fd_cats_rasts[i_cat] = -1;
-+
-+ if(cats_rasts_conds[id_cat]) {
-+ f_cats_rasts_conds[i_cat] = fopen(cats_rasts_conds[id_cat], "r");
-+ if(!f_cats_rasts_conds[i_cat]) {
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids,
-+ f_cats_rasts_conds, f_cats_rasts_conds, scatt_conds->n_a_cats);
-+ G_warning(_("Unable to open category raster condtition file <%s>"), bands[band_id]);
-+ return -1;
-+ }
-+ }
-+ else
-+ f_cats_rasts_conds[i_cat] = NULL;
-+ }
-+
-+ head_nchars = get_cat_rast_header(region, header);
-+ for(i_cat = 0; i_cat < scatt_conds->n_a_cats; i_cat++)
-+ if(f_cats_rasts_conds[i_cat])
-+ if( fseek(f_cats_rasts_conds[i_cat] , head_nchars, SEEK_SET) != 0) {
-+ G_warning(_("Corrupted category raster conditions file (fseek failed)"));
-+ return -1;
-+ }
-+
-+ nrows = Rast_window_rows();
-+
-+ /* analyze bands by rows */
-+ for (i_row = 0; i_row < nrows; i_row++)
-+ {
-+ for(i_band = 0; i_band < n_a_bands; i_band++)
-+ {
-+ band_id = bands_ids[i_band];
-+ Rast_get_c_row(fd_bands[i_band], bands_rows[band_id].row, i_row);
-+ Rast_get_null_value_row (fd_bands[i_band], bands_rows[band_id].null_row, i_row);
-+ }
-+ if(compute_scatts_from_chunk_row(region, scatt_conds, f_cats_rasts_conds, bands_rows, scatts, fd_cats_rasts) == -1)
-+ {
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids, fd_cats_rasts,
-+ f_cats_rasts_conds, scatt_conds->n_a_cats);
-+ return -1;
-+ }
-+
-+ }
-+ free_compute_scatts_data(fd_bands, bands_rows, n_a_bands, bands_ids,
-+ fd_cats_rasts, f_cats_rasts_conds, scatt_conds->n_a_cats);
-+ return 0;
-+}
-+
-+/*!
-+ \brief Merge arrays according to opacity.
-+ Every pixel in array must be represented by 4 values (RGBA).
-+
-+
-+ \param merged_arr array which will be overlayd with overlay_arr
-+ \param overlay_arr array to be merged_arr overlayed with
-+ \param rows number of rows for the both arrays
-+ \param cols number of columns for the both arrays
-+ \param alpha transparency of the overlay array for merging
-+
-+ \return 0
-+*/
-+int I_merge_arrays(unsigned char * merged_arr, unsigned char * overlay_arr, unsigned rows, unsigned cols, double alpha)
-+{
-+ unsigned int i_row, i_col, i_b;
-+ unsigned int row_idx, col_idx, idx;
-+ unsigned int c_a_i, c_a;
-+
-+ for(i_row = 0; i_row < rows; i_row++)
-+ {
-+ row_idx = i_row * cols;
-+ for(i_col = 0; i_col < cols; i_col++)
-+ {
-+ col_idx = 4 * (row_idx + i_col);
-+ idx = col_idx + 3;
-+
-+ c_a = overlay_arr[idx] * alpha;
-+ c_a_i = 255 - c_a;
-+
-+ merged_arr[idx] = (c_a_i * (int)merged_arr[idx] + c_a * 255) / 255;
-+
-+ for(i_b = 0; i_b < 3; i_b++)
-+ {
-+ idx = col_idx + i_b;
-+ merged_arr[idx] = (c_a_i * (int)merged_arr[idx] + c_a * (int)overlay_arr[idx]) / 255;
-+ }
-+ }
-+ }
-+ return 0;
-+}
-+
-+
-+int I_apply_colormap(unsigned char * vals, unsigned char * vals_mask, unsigned vals_size, unsigned char * colmap, unsigned char * col_vals){
-+ unsigned int i_val;
-+ int v, i, i_cm;
-+
-+ for(i_val = 0; i_val < vals_size; i_val++){
-+ i_cm = 4 * i_val;
-+
-+ v = vals[i_val];
-+
-+ if(vals_mask && vals_mask[i_val])
-+ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[258 * 4 + i];
-+ else if(v > 255)
-+ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[257 * 4 + i];
-+ else if(v < 0)
-+ for(i = 0; i < 4; i++) col_vals[i_cm + i] = colmap[256 * 4 + i];
-+ else
-+ for(i = 0; i < 4; i++){ col_vals[i_cm + i] = colmap[v * 4 + i];
-+ }
-+ }
-+ return 0;
-+}
-+
-+
-+int I_rasterize(double * polygon, int pol_n_pts, unsigned char * rast, unsigned char val, struct Cell_head *rast_region){
-+ int i;
-+ int x0, x1, y;
-+ int row, row_idx, i_col;
-+
-+ IClass_perimeter perimeter;
-+
-+ struct line_pnts *pol;
-+ pol = Vect_new_line_struct();
-+
-+ for(i = 0; i < pol_n_pts; i++) {
-+ Vect_append_point(pol,
-+ polygon[i*2],
-+ polygon[i*2 + 1],
-+ 0.0);
-+ }
-+
-+ Rast_set_window(rast_region);
-+
-+ make_perimeter(pol, &perimeter, rast_region);
-+ for (i = 1; i < perimeter.npoints; i += 2) {
-+ y = perimeter.points[i].y;
-+ if (y != perimeter.points[i - 1].y) {
-+ G_warning(_("prepare_signature: scan line %d has odd number of points."),
-+ (i + 1) / 2);
-+ return 1;
-+ }
-+
-+ x0 = perimeter.points[i - 1].x;
-+ x1 = perimeter.points[i].x;
-+
-+ if (x0 > x1) {
-+ G_warning(_("signature: perimeter points out of order."));
-+ return 1;
-+ }
-+
-+ row = (rast_region->rows - y);
-+ if(row < 0 || row >= rast_region->rows) {
-+ continue;
-+ }
-+
-+ row_idx = rast_region->cols * row;
-+
-+ for(i_col = x0; i_col <= x1; i_col++) {
-+ if(i_col < 0 || i_col >= rast_region->cols) {
-+ continue;
-+ }
-+ rast[row_idx + i_col] = val;
-+ }
-+ }
-+
-+ Vect_destroy_line_struct(pol);
-+ G_free(perimeter.points);
-+ return 0;
-+}
More information about the grass-commit
mailing list