Galagone Graphics Tool

Ciao a tutti...

Dato che un socio mi ha chiesto di fare qualcosa di assurdo .. bhe l'ho fatto.
Ecco il mio primo primissimo prodotto dedicato alla grafica, si chiama Galagone è il suo scopo è di rovinare il più possibile le vostre foto.

Gli effetti previsti sono pochi al momento ma di grande utilità per tutte le persone che hanno bisogno di creare degli errori sulle proprie immagini.

Download Galagone

Release Alfa 0.1

plugin presenti:
-BlackBlock ( crea blocchi neri casuali )
-ByteLine ( crea linee non omogenee con interruzioni )
-CircleMaker ( crea cerchi causali in base a colori impostabili )
-DotMacker ( crea punti in base a dei colori impostabili )
-Entropy ( effetto evidenziatore )
-NoiseBlock ( crea blocchi in sovrapposizione alla immagini )
-SimpleBlock ( duplica blocchi di immagine )
-Sobstitute ( cambia un colore con un altro )

Bug noti
non ci sono controlli sui parametri immessi.

E se volete rovinarvi le immagini buon divertimento ...

A tutti i partecipanti del blog se volete i sorgenti ... basta chiedere e come sempre ogni partecipazione è ben accetta !

How To: Draw Berzier

Se non si nota.. sto facendo qualche lavoretto in grafica ( molto per gioco più che per lavoro ) e mi sto pure divertendo .. ammetto che non si tratta di un lavorone, ma di una realizzazione ad-hoc per un amico.

Ci sto provando gusto ...

Posto il non sapere se avete letto o meno il post precedente pubblico in questo le stesse definizioni di prima:

    Graphics g = Graphics.FromImage(img);

    Random r = new Random(
        DateTime.Now.Millisecond + DateTime.Now.Second);    
    
    int x = r.Next(img.Width);
    int y = r.Next(img.Height);

    int x1 = r.Next(img.Width);
    int y1 = r.Next(img.Height);

    int x2 = r.Next(img.Width);
    int y2 = r.Next(img.Height);

    int x3 = r.Next(img.Width);
    int y3 = r.Next(img.Height);

    _Pencil = Color.FromArgb(120, 
                    _Pencil.R, 
                    _Pencil.B, 
                    _Pencil.G);

    Pen p = new Pen(_Pencil, caliber);

    g.DrawBezier(p, 
                    new Point(x, y), 
                    new Point(x1, y1), 
                    new Point(x2, y2), 
                    new Point(x3, y3));

    p = null;

g è il mio oggetto graphics
r è un numero random (....)
_pencil è un oggetto pen ( nel codice ho volutamente messo il blu nel green perchè è in un loop )
_caliber è lo spessore della penna.

per utilizzare i berzier servono minimo 4 punti ... se provate con 3 o con 2 .. non vi portate a casa risultati.

How To: Copy a Region of Image

Non è credibile che sul web ci sia tanta documentazione ma non del tutto corretta... ho trovato tanti esempi ma nessuno ricalcava quello che realmente volevo fare io.

La mia necessità è semplice ho l'immagine A devo copiare una porzione ( che chiameremo B ) ...

    Graphics g = Graphics.FromImage(img);

    Bitmap b = new Bitmap(img);
 
    Bitmap region = new Bitmap(img).Clone(
                        new Rectangle(  x, 
                                        y, 
                                        _blockDimension, 
                                        _blockDimension
                                     ), 
                        System.Drawing.Imaging.PixelFormat.DontCare);
  
    g.DrawImage(region, x1, y1);

Ed ecco la cosa fatta semplice:
img è la mia immagine originale
x,y sono le mie coordinate iniziali
_blockDimension è la dimensione del blocco
g è l'oggetto graphics

In questo modo prendola porzione di immagine che mi serve e la reincollo .. e via..

How To: Full generic Data Adapter.

Parafrasandomi...
L'astrazione del dato è tutto !!

In questo caso mi sono divertito a comprendere se e come fosse possibile arrivare ad  al "limite dell'astrazione".

Partimao da quest'interfaccia, che al momento non serve ma torna comoda. L'idea è di relizzare un raggruppatore di classi entità.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataAbstraction.Data
{
    public interface IEntity<K>
    {
        public K key { get; }
    }
}

E queste le mie classiche entintà che come al solito non si discostano di molto dai miei classici esempi.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataAbstraction.Data
{
    public class Category:IEntity<int>        
    {
        public int id { get; set; }
        public string Name { get; set; }
        public string Descripiton { get; set; }
     
        public int key
        {
            get { return id; }
        }       
    }

    public class Friend:IEntity<int>        
    {
        public int id { get; set; }
        public string Surname { get; set; }
        public string Name { get; set; }
        public Category category { get; set; }

        public int key
        {
            get { return id; }
        }
    }
}

Rispetto allo standard ( sempre del mio blog ) questa è la prima novità, quest'interfaccia ammetto che sembra di dubbia utilità in realtà è questa a reliazzare il salto fra chi gestisce i dati e chi li usa.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace DataAbstraction.Provider
{
    public interface IDataProvider<T>
    {
        List<T> context { get; set; }
        void Insert(T t);
        void Edit(T n, T o);
        void Delete(T t);
        List<T> Select();
    }
}

Ed ecco il gioiellino "il mio nuovo generic dataAdapter" a cui posso far fare quasi tutto ...
L'unica cosa e che per non sfruttare "reflection" che mi potrebbe ammazzare le prestazioni ho dovuto gestire l'edit un un modo un pò bruso, per andare mi serve necessariamente l'item modificato, e il vecchio item. Non escludo qualche evoluzione di questo in futuro, ma penso di essere arrivato ad un buon compromesso, non ho tipi "fissi".

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DataAbstraction.Data;

namespace DataAbstraction.Provider
{
    public class DataProvider<T>:IDataProvider <T>
    {
        List<T> context { get; set; }

        public void Insert(T t)
        {
            context.Add(t);
        }

        public void Edit(T n, T o)
        {
            for (int i = 0; i < context.Count(); i++)
            {
                if (context[i].Equals(o))
                {
                    context[i] = n;
                }
            }
        }

        public void Delete(T t)
        {
            context.Remove(t);
        }

        public List<T> Select()
        {
            return context;
        }
    }
}