public override SlideImage Apply(SlideImage org)
{
SlideImage image;
double r, g, b, intensity;
image = new SlideImage ();
image.CopyProperties (org);
image.Pixels = new byte [org.Stride * org.Height];
for (int i = 0; i < org.Stride * org.Height; i += org.Channels)
{
r = (double) org.Pixels [i];
g = (double) org.Pixels [i + 1];
b = (double) org.Pixels [i + 2];
intensity = (0.299 * r + 0.587 * g + 0.114 * b);
r = 0.94 * intensity;
g = 0.78 * intensity;
b = 0.54 * intensity;
image.Pixels [i + 0] = (byte) r;
image.Pixels [i + 1] = (byte) g;
image.Pixels [i + 2] = (byte) b;
if (org.Channels == 4) // Alpha
image.Pixels [i + 3] = 0xff;
}
return image;
}
void CreateClone(SlideImage src)
{
cloned = new SlideImage ();
cloned.CopyProperties (Source);
cloned.Pixels = new byte [src.Stride * src.Height];
Array.Copy (src.Pixels, cloned.Pixels, src.Stride * src.Height);
}
public SlideImage CreateImage()
{
double percentage;
SlideImage image;
int pos;
percentage = 1d - ((1d / Frames) * CurrentFrame);
image = new SlideImage ();
image.CopyProperties (Source);
image.Pixels = new byte [Source.Stride * Source.Height];
for (int h = 0; h < Source.Height; h++)
{
pos = h * Source.Stride;
for (int w = 0; w < Source.Width; w++)
{
for (int c = 0; c < Source.Channels; c++)
image.Pixels [pos + c] = (byte) (Source.Pixels[pos + c] * percentage);
pos += Source.Channels;
}
}
return image;
}
public override SlideImage Apply(SlideImage org)
{
SlideImage image;
byte r, g, b, intensity;
image = new SlideImage ();
image.CopyProperties (org);
image.Pixels = new byte [org.Stride * org.Height];
for (int i = 0; i < org.Stride * org.Height; i += org.Channels)
{
r = (byte) org.Pixels [i];
g = (byte) org.Pixels [i + 1];
b = (byte) org.Pixels [i + 2];
intensity = (byte) ((double)r * 0.30 + (double)g * 0.59 + (double)b * 0.11);
image.Pixels [i + 0] = intensity;
image.Pixels [i + 1] = intensity;
image.Pixels [i + 2] = intensity;
if (org.Channels == 4) // Alpha
image.Pixels [i + 3] = 0xff;
}
return image;
}
public SlideImage CreateImage()
{
// can't calculate this in constructor because Source is null
if(num_lines_per_frame == -1) {
this.num_lines_per_frame = (int)Math.Ceiling((double) Source.Height / (double) Frames);
this.half = Source.Height / 2;
}
int current_num_line = CurrentFrame * num_lines_per_frame / 2;
int min_line = this.half - current_num_line;
int max_line = this.half + current_num_line;
SlideImage image = new SlideImage ();
image.CopyProperties (Source);
image.Pixels = new byte [Source.Stride * Source.Height];
for (int h = 0; h < Source.Height; h++) {
int pos = h * Source.Stride;
if(h >= min_line && h <= max_line) {
for(int s = 0; s < Source.Stride; s++) {
image.Pixels[pos + s] = Target.Pixels[pos + s];
}
} else {
for(int s = 0; s < Source.Stride; s++) {
image.Pixels[pos + s] = Source.Pixels[pos + s];
}
}
}
return image;
}
public static int AddImageFixed(SlideImage image, uint frames)
{
IntPtr pixels = IntPtr.Zero;
int rslt = -1;
try
{
if (image.Channels != 3)
throw new InvalidOperationException (String.Format ("mistelixvideosrc expects images in 24 bits (3 channels) not {0}", image.Channels));
pixels = Marshal.AllocHGlobal (image.Pixels.Length);
Marshal.Copy (image.Pixels, 0, pixels, image.Pixels.Length);
rslt = mistelix_slideshow_add_imagefixed (pixels, (uint) image.Pixels.Length, frames);
return rslt;
}
finally
{
Marshal.FreeHGlobal (pixels);
}
}
public SlideImage CreateImage()
{
SlideImage image;
int pos;
image = new SlideImage ();
image.CopyProperties (Source);
image.Pixels = new byte [Source.Stride * Source.Height];
// N frames from target image
int h;
for (h = 0; h < Target.Height * ((double) CurrentFrame / (double) Frames); h++)
{
pos = h * Target.Stride;
for (int w = 0; w < Target.Width; w++)
{
for (int c = 0; c < Target.Channels; c++)
image.Pixels[pos + c] = Target.Pixels[pos + c];
pos += Source.Channels;
}
}
// Rest from the source image
for (; h < Source.Height; h++)
{
pos = h * Source.Stride;
for (int w = 0; w < Source.Width; w++)
{
for (int c = 0; c < Source.Channels; c++)
image.Pixels[pos + c] = Source.Pixels[pos + c];
pos += Source.Channels;
}
}
return image;
}
static void Main()
{
SlideImage img;
TimeSpan time;
byte [] pixels;
Project project = new Project ();
Stopwatch stopWatch = new Stopwatch ();
int times = 10;
project.Details.SetResolution (720, 576);
Application.Init ();
stopWatch.Start ();
for (int i = 0; i < times; i++)
{
img = new SlideImage ("../dataset/images/image1.jpg");
img.Title = "Hello world";
img.Project = project;
pixels = img.Pixels;
}
stopWatch.Stop();
time = stopWatch.Elapsed;
Console.WriteLine ("Images with title. Time needed {0}", time);
stopWatch.Reset ();
stopWatch.Start ();
for (int i = 0; i < times; i++)
{
img = new SlideImage ("../dataset/images/image1.jpg");
img.Project = project;
pixels = img.Pixels;
}
time = stopWatch.Elapsed;
Console.WriteLine ("Images. Time needed {0}", time);
return;
}
public abstract SlideImage Apply(SlideImage slideimage);
public DataImageSurface ToDataImageSurface()
{
PixelFormat pixelformat_src;
SlideImage slide = new SlideImage ();
slide.CopyProperties (this);
slide.pixels = (byte[]) this.Pixels.Clone();
slide.ProcessEffects ();
pixelformat_src = slide.pixel_format; // Pixel format of current buffer
slide.pixel_format = PixelFormat.CAIRO_ARGB; // New target format
slide.LoadFromPixelData (slide.pixels, pixelformat_src,
width, height, width * slide.channels, slide.channels);
return new DataImageSurface (DataImageSurface.Allocate (slide.Pixels),
Cairo.Format.ARGB32, slide.width, slide.height, slide.stride);
}
public TransitionPreview()
{
img_a = new Cairo.ImageSurface (Format.Argb32, PREVIEW_WIDTH, PREVIEW_HEIGHT);
Cairo.Context gr = new Cairo.Context (img_a);
// Translators: Used as an example of how a transition looks like, transitioning from 'A' to 'B'
DrawTextCentered (gr, PREVIEW_WIDTH / 2, PREVIEW_HEIGHT / 2, Catalog.GetString ("A"));
((IDisposable)gr).Dispose ();
img_b = new Cairo.ImageSurface (Format.Argb32, PREVIEW_WIDTH, 100);
gr = new Cairo.Context (img_b);
// Translators: Used as an example of how a transition looks like, transitioning from 'A' to 'B'
DrawTextCentered (gr, PREVIEW_WIDTH / 2, PREVIEW_HEIGHT / 2, Catalog.GetString ("B"));
((IDisposable)gr).Dispose ();
slide_a = new SlideImage (img_a);
slide_b = new SlideImage (img_b);
timer = new System.Timers.Timer ();
timer.Elapsed += TimerUpdater;
((IDisposable)img_a).Dispose ();
((IDisposable)img_b).Dispose ();
}
public void CopyProperties(SlideImage src)
{
// TODO: Missing SlideImage properties
width = src.width;
height = src.height;
stride = src.stride;
alpha = src.alpha;
channels = src.channels;
Effects = src.Effects;
project = src.project;
Position = src.Position;
image = src.image;
}
void ShowImage(SlideImage imageToShow)
{
using(DataImageSurface newImage = imageToShow.ToDataImageSurface()) {
ShowImage(newImage);
}
}
// Return true to restart the timeout. Returning false clears the timeout
bool OnNextSlide()
{
if (destroyed)
return false;
if(paused)
return true;
else if(transition.MoveNext()) {
SlideImage newImage = transition.Current as SlideImage;
if(newImage != current_image) {
if(current_image != null)
current_image.ReleasePixels();
current_image = newImage;
ShowImage(current_image);
}
return true;
} else {
ClearTransition();
CurrentIndex++;
Forward();
return false;
}
}
public void Start()
{
if(current_image == null)
CurrentIndex = 0;
if (slide.images.Count == 1) // Single image, just show it
current_image = ResizeImage (CurrentIndex);
if(!PlayingTransition())
Forward();
}
public SlideImage GetSlideThumbnail(int width, int height, bool copyTitle)
{
SlideImage newImage = new SlideImage();
newImage.CopyProperties(this);
using(DataImageSurface thumbnail = this.GetThumbnail(width, height, copyTitle)) {
newImage.FromDataImageSurface(thumbnail);
}
return newImage;
}
// Selected image has changed. Generated from SlideShowImage.
void OnChangeImage(object sender, ShowImageSelectionEventArgs args)
{
bool more;
TreeIter iter;
string transition;
Logger.Debug ("AddSlideDialog.OnChangeImage. Images {0}", args.images.Length);
if (args.images.Length != 1)
return;
selected_image = args.images [0]; // Take the first since all of them will be the same
ImageControlsSensitive (true);
duration_spin.Value = selected_image.ShowTime;
drawing_area.UpdateTransitionType (string.Empty);
// Transition for this image
more = transition_store.GetIterFirst (out iter);
while (more)
{
transition = (string) transition_store.GetValue (iter, (int) ColumnsCombo.Column_Data);
if (selected_image.Transition.Equals (transition)) {
transition_combo.SetActiveIter (iter);
break;
}
more = transition_store.IterNext (ref iter);
}
if (more == false)
SetTransisitionToNone ();
// Text position for this image
TextPosition position;
more = textposition_store.GetIterFirst (out iter);
while (more)
{
position = (TextPosition) textposition_store.GetValue (iter, (int) ColumnsCombo.Column_Data);
if (selected_image.Position == position) {
textposition_combo.SetActiveIter (iter);
return;
}
more = textposition_store.IterNext (ref iter);
}
}
public DataImageSurface GetThumbnail(int width, int height, bool copy_title)
{
PixelFormat pixelformat_src;
SlideImage slide = new SlideImage ();
slide.CopyProperties (this);
if(copy_title)
slide.Title = Title;
slide.LoadAndScaleImage (width, height);
slide.ProcessEffects ();
slide.ProcessImage ();
pixelformat_src = slide.pixel_format; // Pixel format of current buffer
slide.pixel_format = PixelFormat.CAIRO_ARGB; // New target format
slide.LoadFromPixelData (slide.pixels, pixelformat_src,
width, height, width * slide.channels, slide.channels);
return new DataImageSurface (DataImageSurface.Allocate (slide.Pixels),
Cairo.Format.ARGB32, slide.width, slide.height, slide.stride);
}
protected override bool OnExposeEvent(Gdk.EventExpose args)
{
if (!IsRealized)
return false;
if (images_transition == null)
return base.OnExposeEvent(args);
byte[] pixels;
img = (SlideImage) images_transition.Current;
pixels = img.Pixels;
// TODO: To change to the right signature when the new Mono.Cairo is wide spread. Fixed in Mono.Cairo r120299
ImageSurface img_sur = new ImageSurface (ref pixels, Cairo.Format.Argb32, img.Width, img.Height, img.Stride);
Cairo.Context cc = Gdk.CairoHelper.Create (args.Window);
cc.Save ();
cc.SetSourceSurface (img_sur, 0, 0);
cc.Paint ();
cc.Restore ();
img_sur.Destroy ();
((IDisposable)cc).Dispose();
return base.OnExposeEvent(args);
}
protected SlideImage CreateImage(int points, double radius)
{
double percentage;
percentage = ((1d / Frames) * CurrentFrame);
SlideImage image = new SlideImage ();
image.CopyProperties (Source);
image.Pixels = new byte [Target.Stride * Target.Height];
SlideImage draw_image = new SlideImage ();
double cx = Convert.ToInt32 ((Source.Width / 2));
double cy = Convert.ToInt32 ((Source.Height / 2));
double r1 = Target.Width * percentage;
double r2 = Target.Width * percentage * 0.5;
DataImageSurface draw = Source.ToDataImageSurface ();
using (Context gr = new Context (draw))
{
// First paint in black the image.
gr.Save ();
gr.MoveTo (0,0);
gr.LineTo (Target.Width, 0);
gr.LineTo (Target.Width, Target.Height);
gr.LineTo (0, Source.Height);
gr.ClosePath ();
gr.Color = new Color (0,0,0);
gr.Fill ();
gr.Save ();
double x, y;
double x1, y1;
// Draw the points of the star, creating a path with a line
for (int i = 0; i < points; i = i + 2)
{
x = cx + (r1 * System.Math.Cos (i * radius - System.Math.PI / 2));
y = cy + (r1 * System.Math.Sin (i * radius - System.Math.PI / 2));
gr.LineTo (new PointD (x, y));
x1 = cx + (r2 * System.Math.Cos ((i + 1) * radius - System.Math.PI / 2));
y1 = cy + (r2 * System.Math.Sin ((i + 1) * radius - System.Math.PI / 2));
gr.LineTo (new PointD (x1, y1));
}
gr.ClosePath ();
// Fill the resulting polygon with a color
gr.Color = new Color (1, 115, 0);
gr.Fill ();
gr.Restore ();
draw_image.FromDataImageSurface (draw);
bool sourced = percentage < 0.5;
if (sourced)
Array.Copy (Source.Pixels, image.Pixels, Source.Stride * Source.Height);
else
Array.Copy (Target.Pixels, image.Pixels, Target.Stride * Target.Height);
// Draw target image to the star
// Compare Target picture with the temporary
// If in the temporary we have found a black pixel, draw a pixel from the Source slide
// If in the temporary we have found a non-black pixel, draw a pixel from the Target slide
for (int h = 0; h < Target.Height; h++)
{
int pos = h * Target.Stride;
int pos_draw = h * draw_image.Stride;
for (int w = 0; w < Target.Width; w++)
{
if (draw_image.Pixels[pos_draw] != 0) {
if (sourced) {
for (int c = 0; c < Target.Channels; c++)
{
image.Pixels[pos + c] = Target.Pixels[pos + c];
}
}
}else{
if (sourced == false) {
for (int c = 0; c < Target.Channels; c++)
{
image.Pixels[pos + c] = Source.Pixels[pos + c];
}
}
}
pos += Target.Channels;
pos_draw += draw_image.Channels;
}
}
}
((IDisposable) draw).Dispose ();
return image;
}
