overlay results from the CPAN

overlay

Geo-Raster

view release on metacpan or search on metacpan

Geo-Raster
=======================

DESCRIPTION

Geo::Raster has two purposes/goals:

1) To be a general purpose tool for working with geospatial raster
data. This means "raster/map algebra" (overlaying and masking DEMs
(Digital Elevation Models), land-use rasters, etc), spatial analyses
(kriging, ...), extracting indices from the grids (histograms, ...),
etc.

2) To be a general purpose Perl/C tool for doing hydrologic and water
resources GIS work. This means watershed delineation, finding stream
networks, calculating indices (topographic index, ...), preparing data
for hydrologic models, developing spatially distributed hydrologic
modeling, etc.

lib/Geo/Raster.pm view on Meta::CPAN

	return ($min_x, $min_y, $max_x, $max_y);
    } elsif (!$self->{GRID}) {
	return ();
    } else {
	my $w = ral_grid_get_world($self->{GRID});
	return @$w;
    }
    #$self->_attributes;
}

## @method overlayable(Geo::Raster other)
#
# @brief Test if two rasters are overlayable.
sub overlayable {
    my($self, $other) = @_;
    ral_grid_overlayable($self->{GRID}, $other->{GRID});
}

## @ignore
*bounding_box = *world;

## @method copy_world_to(Geo::Raster to)
#
# @brief The method copies the bounding box to the given raster.
# @param[out] to A raster to which the world is copied to.
# @note copy_world_to is a deprecated alias to copy_bounding_box_to

lib/Geo/Raster.pm view on Meta::CPAN

    return $self if defined wantarray;
}

## @method Geo::Raster cross(Geo::Raster b)
# 
# @brief Cross product of rasters.
#
# Creates a new Geo::Raster whose values represent distinct
# combinations of values of the two operand rasters. May be used as
# lvalue or in-place. The operand rasters must be integer rasters and
# the rasters must be overlayable.
# @code
# $c = $a->cross($b);
# $a->cross($b);
# @endcode
#
# If a has values A = a(1), ..., a(n) (a(i) < a(j) if i < j) and b has
# values B = b(1), ..., b(m) (b(i) < b(j) if i < j) then c will have
# max n * m distinct values. The values in c are i(b) + i(a)*n + 1,
# where i(a) is the index of the value of a in array A minus 1 and
# i(b) is the index of the value of b in array B minus 1. c will be

lib/Geo/Raster.pm view on Meta::CPAN


## @method Geo::Raster clip(Geo::Raster area_to_clip)
# 
# @brief Clips a part of the raster according the given rasters real 
# world boundaries.
#
# Example of clipping a raster:
# @code
# $g2 = $g1->clip($g3);
# @endcode
# The example clips from $g1 a piece which is overlayable with $g3. 
# If there is no lvalue, $g1 is clipped.
# 
# @param[in] area_to_clip A Geo::Raster, which defines the area to clip.
# @return If a return value is wanted, then the method returns a new raster with
# size defined by the parameter.
sub clip {
    my $self = shift;
    if (@_ == 4) {
	my($i1, $j1, $i2, $j2) = @_;
	if (defined wantarray) {

lib/Geo/Raster.xs view on Meta::CPAN

			av_push(av, sv);
			sv = newSVnv(xy.max.y);
			av_push(av, sv);
		}
		RETVAL = av;
	}
  OUTPUT:
    RETVAL

int
ral_grid_overlayable(ral_grid *g1, ral_grid *g2)

void
ral_grid_set_bounds_csnn(gd, cell_size, minX, minY)
	ral_grid *gd
	double cell_size
	double minX
	double minY

void
ral_grid_set_bounds_csnx(gd, cell_size, minX, maxY)

lib/Geo/Raster/Layer.pm view on Meta::CPAN

	my $bands = $dataset->{RasterCount};
	
	for my $band (1..$bands) {
	    
	    my $layer = Geo::Raster::Layer->new(filename => $filename, band => $band);
	    
	    my $name = fileparse($filename);
	    $name =~ s/\.\w+$//;
	    $name .= "_$band" if $bands > 1;
	    $gui->add_layer($layer, $name, 1);
	    $gui->{overlay}->render;
	    
	}
    }
    $gui->{tree_view}->set_cursor(Gtk2::TreePath->new(0));
}

sub save_all_rasters {
    my(undef, $gui) = @_;
    my @rasters;
    if ($gui->{overlay}->{layers}) {
	for my $layer (@{$gui->{overlay}->{layers}}) {
	    if (blessed($layer) and $layer->isa('Geo::Raster')) {
		next if $layer->{GDAL};
		push @rasters, $layer;
	    }
	}
    }
    
    croak('No libral layers to save.') unless @rasters;
    
    my $uri = file_chooser('Save all rasters into folder', 'select_folder');

lib/Geo/Raster/Layer/Dialogs/Copy.pm view on Meta::CPAN

    }
    my $combo = $dialog->get_widget('copy_driver_combobox');
    $combo->set_model($model);
    $combo->set_active(0);

    $model = Gtk2::ListStore->new('Glib::String');
    $model->set($model->append, 0, '');
    $model->set($model->append, 0, '<Current view>');
    $model->set($model->append, 0, '<self>');
    my %names;
    for my $layer (@{$gui->{overlay}->{layers}}) {
	my $n = $layer->name();
	$names{$n} = 1;
	next unless $layer->isa('Geo::Raster');
	next if $n eq $self->name();
	$model->set($model->append, 0, $n);
    }
    $combo = $dialog->get_widget('copy_region_combobox');
    $combo->set_model($model);
    $combo->set_active(2);

lib/Geo/Raster/Layer/Dialogs/Copy.pm view on Meta::CPAN

	if ($driver eq 'libral') {
	    Geo::Raster::cache($new_layer);
	    delete $new_layer->{GDAL};
	}
	bless $new_layer => 'Geo::Raster';
    }
    
    $gui->add_layer($new_layer, $name, 1);
    $gui->set_layer($new_layer);
    $gui->select_layer($name);
    $gui->{overlay}->zoom_to($new_layer);
    $self->hide_dialog('copy_raster_dialog') if $close;
    $gui->{overlay}->render;
}

##@ignore
sub cancel_copy {
    my($self, $gui);
    for (@_) {
	next unless ref CORE::eq 'ARRAY';
	($self, $gui) = @{$_};
    }
    $self->hide_dialog('copy_raster_dialog');
    $gui->set_layer($self);
    $gui->{overlay}->render;
    1;
}

sub copy_select_folder {
    my(undef, $self) = @_;
    my $entry = $self->{copy_raster_dialog}->get_widget('copy_folder_entry');
    file_chooser('Select a folder', 'select_folder', $entry);
}

sub copy_driver_selected {

lib/Geo/Raster/Layer/Dialogs/Copy.pm view on Meta::CPAN

sub copy_region_selected {
    my $combo = $_[0];
    my($self, $gui) = @{$_[1]};
    my $dialog = $self->{copy_raster_dialog};
    my $model = $combo->get_model;
    my $iter = $combo->get_active_iter;
    my $region = $model->get($iter);
    my @region;
    if ($region eq '') {
    } elsif ($region eq '<Current view>') {
	@region = $gui->{overlay}->get_viewport();
	push @region, $self->cell_size();
    } else {
	$region = $self->name if $region eq '<self>';
	my $layer = $gui->{overlay}->get_layer_by_name($region);
	@region = $layer->world();
	push @region, $layer->cell_size();
    }
    copy_define_region($self, @region);
}

sub copy_define_region {
    my $self = shift;

    my $dialog = $self->{copy_raster_dialog};

lib/Geo/Raster/Layer/Dialogs/Polygonize.pm view on Meta::CPAN

	$combo->pack_start($renderer, TRUE);
	$combo->add_attribute($renderer, text => 0);

	$combo = $dialog->get_widget('polygonize_datasource_combobox');
	$renderer = Gtk2::CellRendererText->new;
	$combo->pack_start($renderer, TRUE);
	$combo->add_attribute($renderer, text => 0);
    }

    my $model = Gtk2::ListStore->new('Glib::String');
    for my $layer (@{$gui->{overlay}->{layers}}) {
	my $n = $layer->name();
	next unless $layer->isa('Geo::Vector');
	next unless $layer->{update};
	next if $n eq $self->name();
	$model->set($model->append, 0, $n);
    }
    my $combo = $dialog->get_widget('polygonize_name_comboboxentry');
    $combo->set_model($model);
    $combo->set_text_column(0);
    $combo->get_child->set_text($self->name.'_polygonized');

lib/Geo/Raster/Layer/Dialogs/Polygonize.pm view on Meta::CPAN

	$params{options} = { '8CONNECTED' => 1 };
    } else {
	$params{options} = undef;
    }
    $params{callback} = \&progress;
    $params{callback_date} = $dialog->get_widget('polygonize_progressbar');
    my $vector = $self->polygonize(%params);
    print STDERR "pol res $vector\n";
    if ($vector) {
	$gui->add_layer($vector, $into, 1);
	$gui->{overlay}->render;
    }
    $self->hide_dialog('polygonize_dialog') if $close;
    #$gui->set_layer($self);
    #$gui->{overlay}->render;
}

##@ignore
sub cancel_polygonize {
    my($self, $gui);
    for (@_) {
	next unless ref CORE::eq 'ARRAY';
	($self, $gui) = @{$_};
    }

    $self->hide_dialog('polygonize_dialog');
    $gui->set_layer($self);
    $gui->{overlay}->render;
    1;
}

1;

lib/Geo/Raster/Layer/Dialogs/Properties/GDAL.pm view on Meta::CPAN

	$self->alpha($alpha);
	
	my $nodata = get_number_from_entry($dialog->get_widget('gdal_nodata_entry'));
	my $band = $self->band();
	$band->SetNoDataValue($nodata) if $nodata ne '';
    };
    $gui->message("$@") if $@;

    $self->hide_dialog('gdal_properties_dialog') if $close;
    $gui->set_layer($self);
    $gui->{overlay}->render;
}

##@ignore
sub cancel_gdal_properties {
    my($self, $gui);
    for (@_) {
	next unless ref CORE::eq 'ARRAY';
	($self, $gui) = @{$_};
    }

    eval {
	$self->alpha($self->{backup}->{alpha});
	$self->name($self->{backup}->{name});
	my $band = $self->band();
	$band->SetNoDataValue($self->{backup}->{nodata}) if $self->{backup}->{nodata} and $self->{backup}->{nodata} ne '';
    };
    $gui->message("$@") if $@;
    $self->hide_dialog('gdal_properties_dialog');
    $gui->set_layer($self);
    $gui->{overlay}->render;
    1;
}
1;

lib/Geo/Raster/Layer/Dialogs/Properties/libral.pm view on Meta::CPAN

    
	$self->world(minX=>$minX, minY=>$minY, maxX=>$maxX, maxY=>$maxY, cell_size=>$cell_size);
	
	my $nodata = get_number_from_entry($dialog->get_widget('libral_nodata_entry'));
	$self->nodata_value($nodata);
    };
    $gui->message("$@") if $@;

    $self->hide_dialog('libral_properties_dialog') if $close;
    $gui->set_layer($self);
    $gui->{overlay}->render;
}

##@ignore
sub cancel_libral_properties {
    my($self, $gui);
    for (@_) {
	next unless ref CORE::eq 'ARRAY';
	($self, $gui) = @{$_};
    }

    $self->alpha($self->{backup}->{alpha});
    $self->name($self->{backup}->{name});
    $self->world( minX => $self->{backup}->{world}->[0], 
		  minY => $self->{backup}->{world}->[1],
		  cell_size => $self->{backup}->{cell_size} );
    $self->nodata_value($self->{backup}->{nodata});
    $self->hide_dialog('libral_properties_dialog');
    $gui->set_layer($self);
    $gui->{overlay}->render;
    1;
}
1;

lib/Geo/Raster/Operations.pm view on Meta::CPAN

## @class Geo::Raster::Operations
# @brief Adds operations into Geo::Raster and overloads them to operators.
# @note Many methods may convert an integer raster into a floating
# point raster if the operation requires.
# @note All operations, which involve more than one raster, require
# that the rasters are overlayable.
package Geo::Raster;

use strict;
use overload (
	      'fallback' => undef,
              # not having "" overloaded makes print "$raster" to print "1"
	      '""'       => 'as_string', 
	      'bool'     => 'bool',
              '='        => 'shallow_copy',
	      'neg'      => 'neg',

t/00_basic.t view on Meta::CPAN

	ok($g->get(0,1) == 13, "map $datatype 1");
	ok($g->get(1,4) == 56, "map $datatype 2");
	
    }  
}

{
    my $g1 = new Geo::Raster('int',5,5);
    my $g2 = new Geo::Raster('int',5,5);
    my $g3 = new Geo::Raster('int',1,5);
    my $t1 = $g1->overlayable($g2);
    my $t2 = $g1->overlayable($g3);
    ok($t1 == 1, "overlayability");
    ok($t2 == 0, "overlayability");
}

t/09_layer.t view on Meta::CPAN

    }

    # layer list
    my $list = Gtk2::ScrolledWindow->new();
    $list->set_policy("never", "automatic");
    $list->add($gis->{tree_view});
    
    # layer list and the map
    my $hbox = Gtk2::HBox->new(FALSE, 0);
    $hbox->pack_start($list, FALSE, FALSE, 0);
    $hbox->pack_start($gis->{overlay}, TRUE, TRUE, 0);
    
    # the stack
    my $vbox = Gtk2::VBox->new(FALSE, 0);
    $vbox->pack_start($gis->{toolbar}, FALSE, FALSE, 0);
    #$vbox->add($hbox);
    $vbox->pack_start($hbox, TRUE, TRUE, 0);
    $vbox->pack_start($gis->{entry}, FALSE, FALSE, 0);
    $vbox->pack_start($gis->{statusbar}, FALSE, FALSE, 0);

    $window->add($vbox);

t/10_layer.t view on Meta::CPAN

    }

    # layer list
    my $list = Gtk2::ScrolledWindow->new();
    $list->set_policy("never", "automatic");
    $list->add($gis->{tree_view});
    
    # layer list and the map
    my $hbox = Gtk2::HBox->new(FALSE, 0);
    $hbox->pack_start($list, FALSE, FALSE, 0);
    $hbox->pack_start($gis->{overlay}, TRUE, TRUE, 0);
    
    # the stack
    my $vbox = Gtk2::VBox->new(FALSE, 0);
    $vbox->pack_start($gis->{toolbar}, FALSE, FALSE, 0);
    #$vbox->add($hbox);
    $vbox->pack_start($hbox, TRUE, TRUE, 0);
    $vbox->pack_start($gis->{entry}, FALSE, FALSE, 0);
    $vbox->pack_start($gis->{statusbar}, FALSE, FALSE, 0);

    $window->add($vbox);

( run in 3.764 seconds using v1.01-cache-2.11-cpan-49f99fa48dc )