La Maggior Parte Del Modo Efficace Di Filigrana Immagine Di C# A Volare?

Ho un negozio di ecommerce costruito nel asp.net c# (web form) e un sacco di nuove immagini del prodotto sono molto difficili da sorgente, quindi vorrei filigrana con il logo o il nome di dominio.

Ci sono troppi prodotti solo di scaricare le immagini e aggiungere la filigrana, e gli utenti con limitata esperienza di editing immagine sarà il caricamento di nuovi (in Modo che non hanno la minima idea di come aggiungere un watermark).

Quindi credo che questo solo mi lascia con l’utilizzo di un HttpHandler? Sì /No? Se così si può fornire alcune informazioni (Preferibilmente esempi di codice in C#) in modo più efficiente di aggiungere la filigrana, considerando alcune pagine sono circa 20 immagini (Jpeg) su (che devono essere marchiate)

InformationsquelleAutor leen3o | 2010-12-02



6 Replies
  1. 5

    Vorrei ottenere il Graphicsoggetto jpeg, e quindi disegnare la filigrana in cima a quella voce, e salvarlo di nuovo con la filigrana:

    using (Image image = Image.FromFile("myImage.jpg"))
    using(Graphics g = Graphics.FromImage( image)){
      g.DrawImage( myWaterMarkImage, myPosition);
      image.Save(myFilename);
    }
    • Il problema è che probabilmente riduce la qualità dell’immagine di tutta l’immagine a causa jpeg ri-compressione, invece di solo i blocchi dove la filigrana. Ma non so se c’è un modo semplice per farlo meglio.
    • Mentre si riduce la qualità dell’immagine, così a lungo come viene fatto solo una volta non dovrebbe essere un grande problema, soprattutto le specie di dimensioni/risoluzione per una media di immagini per il web. A meno che, naturalmente, la compressione è troppo alto, poi si finisce con una sorta di pasticcio di Vernice produce.
  2. 3

    Ecco un esempio di un HttpHandler

    ///<summary>
    ///Summary description for $codebehindclassname$
    ///</summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    public class ImageHandler : IHttpHandler
    {
    
        public void ProcessRequest(HttpContext context)
        {
            string imageName = string.Empty;
            string physicalPath = string.Empty;
            Image image = null;
            Image thumbnailImage = null;
            Bitmap bitmap = null;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                string actionName = context.Request.QueryString["Image"];
                string opacity = context.Request.QueryString["Opacity"];
                int opacityPercent = int.Parse(opacity);
                Color waterMarkColor = Color.Gray;
                switch (actionName)
                {
                    case "BlueHills":
                        string myCompany = "My Company Name";
                        Font font = new Font("Times New Roman", 8f);
    
                        context.Response.ContentType = "image/png";
                        bitmap = Resources.Resources.BlueHills;
                        Graphics g = Graphics.FromImage(bitmap);
                        Brush myBrush = new SolidBrush(Color.FromArgb(opacityPercent, waterMarkColor));
                        SizeF sz = g.MeasureString(myCompany, font);
                        int X = (int)(bitmap.Width - sz.Width) / 2;
                        int Y = (int)(sz.Height) / 2;
                        g.DrawString(myCompany, font, myBrush, new Point(X, Y));
                        bitmap.Save(memoryStream, ImageFormat.Png);
                        break;
                    default:
                        string test = actionName;
                        break;
                }
    
                context.Response.BinaryWrite(memoryStream.GetBuffer());
                memoryStream.Close();
                if (image != null) { image.Dispose(); }
                if (thumbnailImage != null) { thumbnailImage.Dispose(); }
                if (bitmap != null) { bitmap.Dispose(); }
            }
        }
    
        public bool IsReusable
        {
            get
            {
                return false;
            }
        }
    }

    e può essere chiamato come tale:

    <asp:Image ID="Image1" runat="server" ImageUrl="~/ImageHandler.ashx?Image=BlueHills&Opacity=50" />
  3. 2

    Vi suggerisco di dare un occhiata a WPF classi per fare questo lavoro (GDI+ sono deprecati in un contesto web).

    Il modo (non so se è IL modo MIGLIORE, ma io l’ho già fatto e funziona abbastanza bene) è qualcosa di simile a:

    //Load the original image
    BitmapImage image = new BitmapImage();
    image.BeginInit();
    image.CacheOption = BitmapCacheOption.OnLoad;
    image.UriSource = new Uri(physical_imagepath);
    image.EndInit();
    
    //Create a final render image
    RenderTargetBitmap final = new RenderTargetBitmap(yourNeededWidth, yourNeededHeight, yourDpiDefault, yourDpiDefault, PixelFormats.Default);
    
    DrawingVisual dv = new DrawingVisual();
    
    using (DrawingContext dc = dv.RenderOpen())
    {
        Rect rectImage = new Rect(0, 0, (double)image.PixelWidth, (double)image.PixelHeight);
        dc.DrawImage(image, rectImage);
    
        //Load the bitmap of the watermark
        BitmapImage watermark = new BitmapImage();
        watermark.BeginInit();
        watermark.CacheOption = BitmapCacheOption.OnLoad;
        watermark.UriSource = new Uri(physical_logopath);
        watermark.EndInit();
    
        //Defines the watermark box
        Rect rectWatermark = new Rect(0, 0, (double)watermark.PixelWidth, (double)watermark.PixelHeight);
    
        /* use rectWatermark.X and rectWatermark.Y to move your watermark box around on the final image */
    
        dc.DrawImage(watermark, rectWatermark);
    }
    
    final.Render(dv);
    
    //And then serve the final Bitmap to the client

    Naturalmente, tutti scritti come HttpHandler.
    Il codice di cui sopra non è testato.

    (piccoli annunci: ho pubblicato un CodeCanyon Voce che fare un lavoro simile).

    • Questa è una vecchia risposta, ma spero che si arriva a vedere questo: perché stai usando 96 per i valori di dpi?
    • È arbitrario. Ho dovuto scegliere un dpi fisso per l’uscita, e molti pensano che il 96 dpi andrà a sostituire l’attuale standard web (72dpi)… ma sì, non c’è un VERO motivo
  4. 1

    Questa non è una risposta così più di un paio di consigli:

    1. Jpeg non supporta la trasparenza, la migliore probabilmente si può fare è aggiungere la filigrana di immagine e di godere, colore grigio chiaro.
    2. Uso generico gestore.ashx), è molto leggero e ti impedisce di dover aggiungere nulla sul web.file di configurazione.
    3. Se ci sta per essere verso l’alto di 20 immagini per pagina, allora mi sento di raccomandare l’aggiunta di filigrana, come si ottiene le immagini. Questo è un costo una tantum per l’immagine e rendere il caricamento delle pagine con le immagini più velocemente.

    Non posso garantire per la maggior parte del modo efficace di aggiungere un watermark, ma se si va con il suggerimento #3, diventa meno importante, come si sarà solo eseguire l’operazione una volta sempre per immagine. Io probabilmente basta usare il Sistema.Disegno dello spazio dei nomi per fare questo, basta assicurarsi di smaltire le risorse utilizzate (Immagini, Grafica, ecc), anche se sono sicuro che ci sono librerie là fuori che avrebbe funzionato molto meglio.

    • Fasi intermedie di aggiungere la filigrana non sono legate a un file JPEG restrizioni – così si potrebbe mettere una filigrana trasparente su un’immagine non è un problema.
    • Hai ragione, anche se ho avuto brutte esperienze con il Sistema.Disegno biblioteca durante il caricamento di un’immagine di un tipo e al risparmio di un altro tipo (problemi di qualità delle immagini), quindi io non consiglio di fare così. Inoltre, se si desidera salvare come formato che non consente, in trasparenza, sarebbe gif (che non è buono per immagini di qualità fotografica) o png (che non è supportato da alcuni vecchi browser). Non mi considero un esperto di imaging, queste osservazioni sono basate sulle mie esperienze passate.
  5. 0

    L’ovvia ottimizzazione per qualsiasi ‘on the fly immagine wartermarking’ è per la cache di ‘marchiate’ immagine se ci si può permettere il costo di stoccaggio. Così, l’efficienza del wartermarking operazione in sè non conta molto.

Lascia un commento