source: extensions/pLoader/trunk/src/Uploader/ResizeWorker.pm @ 6709

package Uploader::ResizeWorker;
use threads;
use threads::shared;
use strict;
use base qw/Uploader::Object/;
use Image::Magick;
use Data::Dumper;

$|=1;

__PACKAGE__->mk_accessors(qw/
    preferences
    wx_thumb_dir
    thumb_dir
    resized_dir
    write_type
    progress_event
    done_event
    event_handler
    cancel_event
    gravity
    rgbcolor
/);


sub Init {
    my ( $self ) =@_;

    $self->gravity(
        { 
            'Top'          => 'North',
            'Left'         => 'West',
            'Right'        => 'East',
            'Bottom'       => 'South',
            'Top left'     => 'NorthWest',
            'Top right'    => 'NorthEast',
            'Bottom left'  => 'SouthWest',
            'Bottom right' => 'SouthEast',
            'Center'       => 'Center',
       }   
    );    

    $self->rgbcolor(
        {
            "White" => '#FFFFFF',
            "Black" => '#000000',
        }    
    );
}


sub cancel_image {
    my ( $self, $image ) = @_;
    
    #must check if $image is a valid hash
    return unless 'HASH' eq ref $image;
    return unless $image->{image_id};

    $self->log_image_progress(
        $image,
        $self->localized_msg->{"cancelled"},
        0,
    );
}


sub process_image {
    my ( $self, $handler, $progress_event, $resize_done_event, $image ) = @_;

    $self->event_handler(
        $handler
    );


    $self->progress_event(
        $progress_event
    );

    $self->done_event(
        $resize_done_event
    );

    $self->resize_image($image);
    $self->process_high_image($image);
    $self->thumbnail_image($image);

    $self->post_image_done_event($image);
}


sub post_image_progress_event {
    my ( $self, $image ) = @_;

    $self->post_image_event(
        $self->progress_event,
        $image
    );
}


sub post_image_done_event {
    my ( $self, $image ) = @_;

    $image->{status}   = $self->localized_msg->{"prepared, waiting for transfer"};
    $image->{progress} = 25;

    $self->post_image_event(
        $self->done_event,
        $image
    );
}


sub post_image_cancel_event {
    my ( $self, $image ) = @_;

    $image->{status}   = "cancelled";
    $image->{progress} = 0;

    $self->post_image_event(
        $self->cancel_event,
        $image
    );
}




sub post_image_event {
    my ( $self, $event_type, $image ) = @_;

    my $thread_event = Wx::PlThreadEvent->new(
        -1,
        $event_type,
        shared_clone($image)
    );

    eval {
        Wx::PostEvent($self->event_handler, $thread_event);
    }

}


sub resize_image {
    my ( $self, $image ) = @_;

    $self->log_image_progress(
        $image,
        $self->localized_msg->{"preparing web size"},
        5,
    );

    my $preferences = $image->{preferences};

    if( $preferences->{create_resized} ){
        $self->create_resized($image);
    }
    # the original is at the right size, no need to create a resize
    else {
        #printf("original no resized %s\n", $self->create_resized);
        $image->{site_resized_file} = $image->{file};
    }

    $self->log_image_progress(
        $image,
        $self->localized_msg->{"web size prepared"},
        10,
    );

}


sub log_image_progress {
    my ( $self, $image, $status, $value ) = @_;

    $image->{status}   = $status;
    $image->{progress} = $value;
    $self->post_image_progress_event($image);
}


sub process_high_image {
    my ( $self, $image ) = @_;

    my $decode = {
        'No' => 0,
        'Yes, use HD resized of the original photo' => 'HD',
        'Yes, use a copy of the original photo' => 'ORIGINAL',
    };

    my $preferences = $image->{preferences};
    $image->{upload_high} = $decode->{$preferences->{upload_hd}};
    # if upload high, rotate a copy of original file
    if($image->{upload_high}){
        $self->create_high($image);
    }
}


# $image is a hash, not an object
sub create_resized {
    my ( $self, $image ) = @_;

    my $rval = 1 ;

    $image->{site_resized_file} = File::Spec->catfile(
        $self->resized_dir,
        sprintf(
            "%s.%s.%s",
            $image->{image_id},
            $image->{global_rank},
            $self->write_type,
        ),
    );

    my $imgk = new Image::Magick;

    my $status = $imgk->ReadImage(
        $image->{file}
    );
    warn "$status" if $status ;
    return 0 if $status;

    my $w = $imgk->Get('width');
    my $h = $imgk->Get('height');

    $status = $imgk->Set(Gravity=>"Center");
    warn "$status" if $status ;

    # exif from original image
    my $orientation = $image->{exif_metadata}{Orientation};
    my $preferences = $image->{preferences};
    
    # Valid for Rotate 180, Rotate 90 CW, Rotate 270 CW
    if( $orientation =~ m/Rotate (\d+)/ ){
        printf(
            "Rotate %s\n",
            $1
        );
    
        $imgk->Rotate( degrees=>$1 ) if $preferences->{auto_rotate};    
    }


    #printf("resize with blur value %s\n", $self->blur);
    $status = $imgk->Resize(
        geometry => sprintf(
            "%sx%s>",
            $preferences->{resize_w},
            $preferences->{resize_h}
        ),
        filter => sprintf(
            "%s",
            $preferences->{filter}
        ), 
        blur => $preferences->{blur}
    );
    warn "$status" if $status ;
    return 0 if $status;

    #printf("resize with quality value %s\n", $self->quality);
    $status = $imgk->Set(quality=>$preferences->{quality});
    warn "$status" if $status ;

    $status = $imgk->Set(interlace=>$preferences->{interlace});
    warn "$status" if $status ;

    $imgk->Write(
        sprintf(
            "%s:%s",
            $self->write_type,
            $image->{site_resized_file},
        )
    );
    warn "$status" if $status ;
    return 0 if $status;
    
    undef $imgk;

    if($preferences->{watermark_activate}){
        $self->create_watermark(
            $preferences,
            $image->{site_resized_file}
        );
    }

   
    $rval = 0 if $status;

    return $rval;
}

# $image is a hash, not an object
sub thumbnail_image {
    my ( $self, $image ) = @_;
    
    my $rval = 1;

    $image->{site_thumb_file} = File::Spec->catfile(
        $self->thumb_dir,
        sprintf(
            "%s.%s.%s",
            $image->{image_id},
            $image->{global_rank},
            $self->write_type,
        ),
    );


    my $imgk = new Image::Magick;

    my $status = $imgk->ReadImage(
        $image->{site_resized_file}
    );
    warn "$status" if $status ;

    my $preferences = $image->{preferences};
    my $pattern = $preferences->{thumbnail_shape_square} ?
        "%sx%s^" :
        "%sx%s>" ;
    $status = $imgk->Resize(
        geometry => sprintf(
            $pattern, 
            $preferences->{thumb_size}, 
            $preferences->{thumb_size}
        ),
    );
    warn "$status" if $status ;

    $status = $imgk->Set(Gravity=>"Center");
    warn "$status" if $status ;

    $status = $imgk->Crop(
        geometry=>sprintf(
            "%sx%s+0+0",
            $preferences->{thumb_size},
            $preferences->{thumb_size}
        )
    ) if $preferences->{thumbnail_shape_square};


    $status = $imgk->Set(quality=>$preferences->{th_quality});
    warn "$status" if $status ;

    $status = $imgk->Strip();
    warn "$status" if $status ;


    $imgk->Write(
        sprintf(
            "%s:%s",
            $self->write_type,
            $image->{site_thumb_file},
        )
    );
    
    undef $image;


    $rval = 0 if $status;

    return $rval;
}


sub create_high {
    my ( $self, $image ) = @_;

    $self->log_image_progress(
        $image,
        $self->localized_msg->{"preparing high"},
        15,
    );

    $self->set_site_high_file($image);

    my $bModifyOriginal;
    my $bRotate;
    my $bAddWatermark;
    my $bResize;
    my $orientation = $image->{exif_metadata}{Orientation};
    my $degrees;
    
    my $preferences = $image->{preferences};
    # Valid for Rotate 180, Rotate 90 CW, Rotate 270 CW
    if( $preferences->{auto_rotate} and $orientation =~ m/Rotate (\d+)/ ){
        $bModifyOriginal = 1;
        $bRotate = 1;
        $degrees = $1;
    }

    if( $preferences->{watermark_activate_pwg_high} ){
        $bModifyOriginal = 1;
        $bAddWatermark = 1;
    }
    
    # HD resize
    if('HD' eq $image->{upload_high}){
        $bModifyOriginal = 1;
        $bResize = 1;
    }

    if($bModifyOriginal){

        my $imgk = Image::Magick->new();
        # we read original
        my $status = $imgk->Read(
            $image->{file}
        );
        warn "$status ", $image->{file}, "\n" if $status ;
        return 0 if $status;

        if($bRotate){
            $imgk->Rotate( degrees=>$degrees );    
        }        
        $imgk->Write(
            $image->{site_high_file}
        );
        warn "$status ", $image->{site_high_file}, "\n" if $status ;
        return 0 if $status;

        if($bResize){
            $status = $imgk->Resize(
                geometry => sprintf(
                    "%sx%s>",
                    $preferences->{hd_w},
                    $preferences->{hd_h}
                ), 
                filter => sprintf(
                    "%s",
                    $preferences->{hd_filter}
                ), 
                blur => $preferences->{hd_blur}
            );
            warn "$status" if $status ;
            return 0 if $status;
        }
        
        #printf("resize with quality value %s\n", $self->quality);
        $status = $imgk->Set(quality=>$preferences->{quality});
        warn "$status" if $status ;

        $status = $imgk->Set(interlace=>$preferences->{interlace});
        warn "$status" if $status ;
        
        $imgk->Write(
            sprintf(
                "%s:%s",
                $self->write_type,
                $image->{site_high_file},
            )
        );
        warn "$status" if $status ;
        
        undef $imgk;

        if($bAddWatermark){
            $self->create_watermark(
                $image->{preferences},
                $image->{site_high_file}
            );
        }

        $self->set_file_exif_tag(
            $image->{site_high_file},
            'Orientation',
            'Horizontal (normal)',
        );

        # Now all images that need to be rotated are done. Update exif
        $image->{exif_metadata}{Orientation} = 'Horizontal (normal)';


    }
    else{
        # high file is the original file
        $image->{site_high_file} = $image->{file};
        #printf("site high file %s\n", $self->current_image->site_high_file);
    }
    $self->log_image_progress(
        $image,
        $self->localized_msg->{"high prepared"},
        25,
    );

    return 1;

}


sub set_site_high_file {
    my ( $self, $image ) = @_;

    my ( $vol, $dir, $file ) = File::Spec->splitpath(
        $image->{file}
    );
    
    my ( $filename, $ext ) = split /\./, $file ;
    
    # high_file is a resized of original
    $image->{site_high_file} = File::Spec->catfile(
        $self->resized_dir,
        sprintf(
            "%s_high.%s.%s",
            $image->{image_id},
            $image->{global_rank},
            $self->write_type,
        ),
    );
}


sub create_watermark {
    my ( $self, $preferences, $file_out ) = @_;
    
    my $rval = 1 ;

    my $text = $preferences->{watermark_text};
    my $text_size = $preferences->{watermark_text_size};
    my $w_position = $preferences->{watermark_position};
    my $x = $preferences->{watermark_x};
    my $y = $preferences->{watermark_y};
    my $color = $preferences->{watermark_color};

    my $gravity = $self->gravity->{$w_position};
    my $fill = $self->rgbcolor->{$color};

    # debug
    #printf("Create watermark %s\n", $file_out);

    

    my $imgk = new Image::Magick;
    
    my $status = $imgk->ReadImage(
        $file_out
    );      

    my $ratio = $imgk->Get('height')/($preferences->{resize_h}||$imgk->Get('height'));
    $ratio||=1;
    $text ||="Your watermark";
    $imgk->Annotate(
        pointsize => $text_size*$ratio,
        fill => $fill,
        x => $x*$ratio,
        y => $y*$ratio,
        text => $text,
        gravity => $gravity,
    );
                      
    $imgk->Write(
        sprintf(
            "%s:%s",
            $self->write_type,
            $file_out,
        )
    );
}


sub set_file_exif_tag {
    my ( $self, $file, $tag, $newValue ) = @_;    

    my $options = {};
    # Create a new Image::ExifTool object
    my $exifTool = new Image::ExifTool;

    # Extract meta information from an image
    $exifTool->ExtractInfo($file, $options);

    # Set a new value for a tag
    $exifTool->SetNewValue($tag, $newValue);

    # Write new meta information to a file
    $exifTool->WriteInfo($file);

}


# used for display in GUI. has to fit a square box ( wxImageList )
# $image is an object
sub create_wx_thumbnail {
    my ( $self, $image ) = @_;


    $image->wx_thumb_file( 
        File::Spec->catfile(
            $self->wx_thumb_dir,
            sprintf(
                "%s.%s.%s",
                $image->image_id,
                $image->global_rank,
                $self->write_type,
            ),
        )
    );


    my $rval = 0;
    my $imgk = new Image::Magick;

    my $preferences = $image->{preferences};
    my $size = $preferences->{wx_thumb_size}||100;

    my $status = $imgk->Set(size=>sprintf("%sx%s", 2*$size, 2*$size));
    warn "$status" if $status ;

    $status = $imgk->ReadImage(
        $image->file
    );
    warn "$status" if $status;
    return $rval if $status;

    # maximize size and keep aspect ratio
    $status = $imgk->Thumbnail(
        geometry=>sprintf("%s%s>", $size*$size, '@')
    );
    # to get adjusted to a square box
    #$status = $image->Thumbnail(
    #    geometry=>sprintf("%sx%s%s", $size, $size, '^')
    #);
    warn "$status" if $status;
    return $rval if $status;

    $status = $imgk->Set(Gravity=>"Center");
    warn "$status" if $status ;

    $imgk->Extent(
        geometry=>sprintf("%sx%s", $size, $size),
        gravity=>'center',
    );
    
    $imgk->Set(
        quality=>$preferences->{wx_quality}||90
    );

    $status = $imgk->Strip();
    warn "$status" if $status ;

    # exif from original image
    my $orientation = $image->exif_metadata->{Orientation};
    
    # Valid for Rotate 180, Rotate 90 CW, Rotate 270 CW
    if( $orientation =~ m/Rotate (\d+)/ ){
        printf(
            "Rotate %s\n",
            $1
        );
    
        $imgk->Rotate( degrees=>$1 ) if $preferences->{auto_rotate};    
    }
    

    $imgk->Write(
        sprintf(
            "%s:%s",
            $self->write_type,
            $image->wx_thumb_file,
        )
    );

    undef $imgk;
    
    $rval = 1;
    
    return $rval;
}


1;