none
Quale versione .NET utilizzo ?? RRS feed

  • Domanda

  • Salve a tutti , proseguo nelle mie domande (forse banali)

    Ho problemi nel gestire le bitmap  :  teoricamente dovrebbero  arrivare  a  65.536  x  65536

    ma ho il sospetto che non sia così  e  che  dipenda  dalla versione  .NET  che  utilizzo

    Come faccio a sapere quale versione uso  ?

    L' ambiente è VisualStudio  2019   C#   Window  10  64 bit    processore  a  64 bit

    Servono altre informazioni  ??

    Grazie  per  l'eventuale attenzione

    mercoledì 7 settembre 2022 11:27

Risposte

  • Ciao Vittorio,

    la versione del framework la stabilisci tu nel progetto, quindi la trovi tra le proprietà di quest'ultimo.

    Solitamente da visual studio dovresti cliccare con il tasto destro sul progetto visualizzato in "Esplora soluzioni" (di solito a dx dello schermo), dopo scegliere proprietà, tra quei dati dovresti trovare il framework di destinazione (la "versione net").

    Il limite sta negli oggetti CLI che hanno una dimensione massima di 2 gb (se non ricordo male) fina al framework 4.5, che dovrebbe andare ben oltre. Quindi il discorso non è tanto dimensione dell'immagine in se, ma proprio il peso. Considera che le bitmap cambiano "peso" non solo in base alla dimensione (larghezza e altezza), ma anche dalla profondità di immagine (numero di bit necessari ad esprimere un colore, con un numero più alto è possibile definire più colori, ergo più qualità ma piu peso).

    mercoledì 7 settembre 2022 13:44
  • Ciao Vittorio,

    nelle tue prove mi pare ci siano delle imprecisioni.

    Il calcolo che fai non è corretto, in quanto di default le bitmap usano 4 byte per pixel, quindi il calcolo che devi fare è: 65,535*65,535*4.

    anche l'area che hai scritto sarebbe 534000000*4=2.136.000.000, che sono circa 2 gb, ovvero la limitazione che ti ho indicato.

    Detto ciò aggiungo che non basta "binarizzare" il colore, in quanto si parla di bitmap che di default usa 32 bit (4 byte, 1 byte per canale x 4 canali che sono Alpha Red Green Blue), che poi quei pixel siano in bianco e nero non conta nulla perché comunque servono sempre 4 byte per pixel per esprimere un colore ARGB. Per poter ridurre il numero di bit per pixel devi specificarlo nel costruttore quando crei la bitmap:

    var bitmap = new Bitmap(65535, 65535, Imaging.PixelFormat.Format1bppIndexed)

    In questo caso funziona anche con 65535*65535. Oppure con argb devi usare il net framework >= 4.5 ed abilitare "gcAllowVeryLargeObjects" nel file di configurazione dell'app (app.config)

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
      ...
      <runtime>
        <gcAllowVeryLargeObjects enabled="true" />
      </runtime>
    </configuration>

    Oltre a compilare per x64 ed avere memoria a sufficienza.

    Esplora soluzioni è il riquadro che ti mostra i vari file del progetto, se non lo hai già visibile (sulla destra) cliccando in visualizza lo trovi (come detto da te), ma quello non fa altro che mostrarti il riquadro, dopo, nel riquadro, devi cliccare con il tasto destro sul nome del progetto e scegliere proprietà, dalla schermata che ti si apre dovresti trovare il framework di destinazione. Oppure se ti piace agire dai menu, allora vai nella voce "progetto" e scegli l'ultima voce, ovvero: proprietà di [nome progetto che hai dato].


    • Modificato U 235 giovedì 8 settembre 2022 11:04
    • Contrassegnato come risposta vittorio 50 venerdì 9 settembre 2022 09:13
    giovedì 8 settembre 2022 10:31
  • Ciao Vittorio,

    non concordo sul fatto che non abbia abbastanza tempo per imparare c# e visual studio, a meno che non mi dica che a breve dovrai andare a trovare il padre eterno (o qualsiasi altra cosa legata alla dipartita)... ma spero proprio non sia così. Sia se 50 è il tuo anno di nascita, sia se é la tua età, salvo imprevisti hai tutto il tempo di imparare se vuoi. Certo magari più per cultura personale che per lavoro, ma non é del tutto vero neanche questo.

    Ho l'impressione che tu provenga dal vb, nello specifico secondo me provieni dal vecchio asp classic ed usavi vbs. Gli ostacoli che stai trovando sono tutti facilmente oltrepassabili studiando le basi di net. Per esempio il fatto che non sai gestire la questione dell'errore di Imaging indica una carenza di basi, cosa che puoi risolvere facilmente... si tratta di includere le giuste direttive using oppure specificare il namespace per intero:

    System.Drawing.Imaging.PixelFormat.Format1bppIndexed

    oppure puoi fare questo:

    using System.Drawing.Imaging; ...

    ... var bitmap = new Bitmap(65535, 65535, PixelFormat.Format1bppIndexed)


    In questo caso non hai bisogno di specificare piu "System.Drawing.Imaging" ma solo la parte rimanente, quindi solo "PixelFormat.Format1bppIndexed". 

    Non ti preoccupare, ognuno impara a modo suo, e anche tu alla fine sarai in grado di risolvere questi problemi. Certo non basta "smanettare", dovresti anche studiare come funziona .NET

    In bocca al lupo!

    • Contrassegnato come risposta vittorio 50 sabato 10 settembre 2022 09:56
    venerdì 9 settembre 2022 20:07

Tutte le risposte

  • Ciao Vittorio,

    la versione del framework la stabilisci tu nel progetto, quindi la trovi tra le proprietà di quest'ultimo.

    Solitamente da visual studio dovresti cliccare con il tasto destro sul progetto visualizzato in "Esplora soluzioni" (di solito a dx dello schermo), dopo scegliere proprietà, tra quei dati dovresti trovare il framework di destinazione (la "versione net").

    Il limite sta negli oggetti CLI che hanno una dimensione massima di 2 gb (se non ricordo male) fina al framework 4.5, che dovrebbe andare ben oltre. Quindi il discorso non è tanto dimensione dell'immagine in se, ma proprio il peso. Considera che le bitmap cambiano "peso" non solo in base alla dimensione (larghezza e altezza), ma anche dalla profondità di immagine (numero di bit necessari ad esprimere un colore, con un numero più alto è possibile definire più colori, ergo più qualità ma piu peso).

    mercoledì 7 settembre 2022 13:44
  • Ciao  U 235 ,

    ho  fatto  un  pò  di   prove  e  le  conclusioni  sono  :

    • FA4 = new Bitmap(largo, alto);     dove  sia  largo  che  alto  <= 65535  pixel
    • quindi  teoricamente   65535 * 65535   =  4.294.836.225
    • in  realtà  :  largo * alto  >  534.000.000   segnala  errore  :  parametro  non  valido
    • non  capisco  perchè
    • l' oggetto  grafico  che  utilizzo  non  ha  colore  :  in  realtà  è  solo  un  diagramma  cartesiano  ( asse x , asse y ) seguito da una successione  di  righe  con  dati  alfanumerici  incolonnati  ;  il  tutto  in  nero  su  sfondo  bianco
    • ho  trovato  Esplora  soluzioni  solo  sotto  Visualizza  ( in alto a sinistra )  ma  dentro  non  ho  trovato  voci  framework
    • nella  stesura  del  progetto  sono  stato  guidato  ( non sapevo nulla di  IDE ) quindi non  ricordo  cosa  è  stato  fatto

    Grazie  comunque   per  l' attenzione

    giovedì 8 settembre 2022 08:46
  • Ciao Vittorio,

    nelle tue prove mi pare ci siano delle imprecisioni.

    Il calcolo che fai non è corretto, in quanto di default le bitmap usano 4 byte per pixel, quindi il calcolo che devi fare è: 65,535*65,535*4.

    anche l'area che hai scritto sarebbe 534000000*4=2.136.000.000, che sono circa 2 gb, ovvero la limitazione che ti ho indicato.

    Detto ciò aggiungo che non basta "binarizzare" il colore, in quanto si parla di bitmap che di default usa 32 bit (4 byte, 1 byte per canale x 4 canali che sono Alpha Red Green Blue), che poi quei pixel siano in bianco e nero non conta nulla perché comunque servono sempre 4 byte per pixel per esprimere un colore ARGB. Per poter ridurre il numero di bit per pixel devi specificarlo nel costruttore quando crei la bitmap:

    var bitmap = new Bitmap(65535, 65535, Imaging.PixelFormat.Format1bppIndexed)

    In questo caso funziona anche con 65535*65535. Oppure con argb devi usare il net framework >= 4.5 ed abilitare "gcAllowVeryLargeObjects" nel file di configurazione dell'app (app.config)

    <?xml version="1.0" encoding="utf-8" ?>
    <configuration>
      ...
      <runtime>
        <gcAllowVeryLargeObjects enabled="true" />
      </runtime>
    </configuration>

    Oltre a compilare per x64 ed avere memoria a sufficienza.

    Esplora soluzioni è il riquadro che ti mostra i vari file del progetto, se non lo hai già visibile (sulla destra) cliccando in visualizza lo trovi (come detto da te), ma quello non fa altro che mostrarti il riquadro, dopo, nel riquadro, devi cliccare con il tasto destro sul nome del progetto e scegliere proprietà, dalla schermata che ti si apre dovresti trovare il framework di destinazione. Oppure se ti piace agire dai menu, allora vai nella voce "progetto" e scegli l'ultima voce, ovvero: proprietà di [nome progetto che hai dato].


    • Modificato U 235 giovedì 8 settembre 2022 11:04
    • Contrassegnato come risposta vittorio 50 venerdì 9 settembre 2022 09:13
    giovedì 8 settembre 2022 10:31
  • Ciao  "pericolosissimo"  U 235 ,

    grazie per la spiegazione , ho capito (non tutto) limitatamente alle mie conoscenze che sono molto scarse

    D'altra parte , concorderai che non mi resta abbastanza tempo  sia  per imparare  ad usare VisualStudio  sia  per scrivere del codice .

    Ho trovato che la versione NET che utilizzo dovrebbe essere  4.7.2

    Ho provato  :    

    var bitmap = new Bitmap(65535, 65535, Imaging.PixelFormat.Format1bppIndexed)

    ma viene segnalato che il termine Imaging non esiste nel contesto corrente ( manca qualcosa ? )

    La cosa più importante , alla fine , è conoscere i limiti così da evitare errori in run-time

    venerdì 9 settembre 2022 09:23
  • Ciao Vittorio,

    non concordo sul fatto che non abbia abbastanza tempo per imparare c# e visual studio, a meno che non mi dica che a breve dovrai andare a trovare il padre eterno (o qualsiasi altra cosa legata alla dipartita)... ma spero proprio non sia così. Sia se 50 è il tuo anno di nascita, sia se é la tua età, salvo imprevisti hai tutto il tempo di imparare se vuoi. Certo magari più per cultura personale che per lavoro, ma non é del tutto vero neanche questo.

    Ho l'impressione che tu provenga dal vb, nello specifico secondo me provieni dal vecchio asp classic ed usavi vbs. Gli ostacoli che stai trovando sono tutti facilmente oltrepassabili studiando le basi di net. Per esempio il fatto che non sai gestire la questione dell'errore di Imaging indica una carenza di basi, cosa che puoi risolvere facilmente... si tratta di includere le giuste direttive using oppure specificare il namespace per intero:

    System.Drawing.Imaging.PixelFormat.Format1bppIndexed

    oppure puoi fare questo:

    using System.Drawing.Imaging; ...

    ... var bitmap = new Bitmap(65535, 65535, PixelFormat.Format1bppIndexed)


    In questo caso non hai bisogno di specificare piu "System.Drawing.Imaging" ma solo la parte rimanente, quindi solo "PixelFormat.Format1bppIndexed". 

    Non ti preoccupare, ognuno impara a modo suo, e anche tu alla fine sarai in grado di risolvere questi problemi. Certo non basta "smanettare", dovresti anche studiare come funziona .NET

    In bocca al lupo!

    • Contrassegnato come risposta vittorio 50 sabato 10 settembre 2022 09:56
    venerdì 9 settembre 2022 20:07
  • Ciao  U235 ,

    FUNZIONA  !!

    Grazie  a  te  ed  a  tutti  quanti  per l' attenzione  e  la  pazienza .

    Purtroppo  50  è  solo  un  numero  casuale  capitato  non  so  come . Il  mio  anno  di  nascita  è  parecchio  più  piccolo .

    Non  me  la  sarei  sentita  di  ricominciare  senza  la  disponibilità  di  generose  persone  che  ( grazie  anche  al  lockdown  del  2020 ) mi  hanno  letteralmente  preso  per  mano , guidandomi  da  remoto nell ' iniziare  questa  avventura  meravigliosa .

    Quando programmavo  era  il  tempo  dell' IBM  5110  ,  non  ho  mai  saputo  dell' esistenza  di  strutture  per  programmare  tipo  IDE ,

    il  vangelo  era  il  C  ed  il  debug  me  lo  sono  costruito  io  (alla  buona) .

    Ora , grazie  a  tutti  voi  mi  sto  divertendo  un  mondo  a  fare  e  disfare  un'applicazione  generica  che , MI  HANNO  DETTO , è  un  vero  e  proprio  linguaggio  di  programmazione . Sarà  per  questo  che  a  volte  trovo  difficoltà  a  confrontarmi  con  strutture  di  codice  uscite  direttamente  dall ' IDE  ( cosa che , come  hai  perfettamente  capito , non riesco e  non voglio utilizzare ).

    sabato 10 settembre 2022 10:12
  • Mi  correggo  U235 ,

    NON  FUNZIONA , o   meglio  funziona  la  creazione  della bitmap          

      FA4 = new Bitmap(largo, alto, PixelFormat.Format1bppIndexed);

    ma  poi  creo  l' oggetto ;     

       g = Graphics.FromImage(FA4);  

    per  scriverci  :

       g.DrawString( ... );

    ed  appare  il  messaggio  di  errore  :

      Impossibile  creare  un  oggetto  Graphics  da  un'immagine  con  formato  a  pixel  indicizzati .

    sabato 10 settembre 2022 10:45
  • Purtroppo con quel tipo di formato non puoi usare l'oggetto graphics, e nemmeno "setPixel" mi sa...

    In questo caso la cosa diventa un po' più complicata, forse anche troppo a meno che non sia davvero necessario usare bitmap così grandi.

    In pratica si tratta di scrivere pixel per pixel l'immagine usando LockBits. Chiaramente essendo davvero complicato calcolare i colori dei pixel uno per uno per creare le scritte, ti potresti aiutare scrivendo bitmap piu piccole (ma a 32 bit in modo da poter usare l'oggetto graphics su essa) come stai facendo ora, dopo copi i pixel risultanti dalle bitmap a 32 bit vai a formare un "collage" sull'immagine più grande (ma ad 1 bit) composta da tutte le bitmap piccole. 

    in pratica usi questo metodo:

    public static Bitmap BitmapTo1Bpp(Bitmap dest, Bitmap src,Rectangle rect)
            {
                int w = dest.Width;
                int h = dest.Height;
                BitmapData data = src.LockBits(rect, ImageLockMode.ReadWrite, PixelFormat.Format1bppIndexed);
                byte[] scan = new byte[(w + 7) / 8];
                for (int y = 0; y < h; y++)
                {
                    for (int x = 0; x < w; x++)
                    {
                        if (x % 8 == 0) scan[x / 8] = 0;
                        Color c = dest.GetPixel(x, y);
                        if (c.GetBrightness() >= 0.5) scan[x / 8] |= (byte)(0x80 >> (x % 8));
                    }
                    Marshal.Copy(scan, 0, (IntPtr)((long)data.Scan0 + data.Stride * y), scan.Length);
                }
                src.UnlockBits(data);
                return src;
            }


    Che ti permette di copiare il contenuto di un immagine sorgente a 32 bit (una normale bitmap su cui hai scritto usando l'oggetto graphics), in una bitmap di destinazione a 1 bit in un punto preciso. Il punto in cui scrivere ovviamente devi inserirlo tu, ovvero dividi "idealmente" la bitmap di destinazione in tanti quadranti della stessa dimensione e li affianchi andando a formare "righe", poi riga per riga formi l'altezza.

    esempio:

    private static void CreateBtm()
            {
                //bitmap risultante a 1 bit
                var finalBitmap = new Bitmap(10000, 10000, PixelFormat.Format1bppIndexed);
                //bitmap che uso per scrivere con graphics
                var src = new Bitmap(100, 100);
                //numero di riquadri in larghezza
                var wDim = finalBitmap.Width / src.Width;
                //numero di riquadri in altezza
                var hDim = finalBitmap.Height / src.Height;
                //ciclo che compone i riquadri
                for (int w=0;w<wDim ;w++ )
                {
                    for (int h = 0; h < hDim; h++)
                    {
                        //scrivo sulla bitmap "riquadro" a 32 bit
                        using (var gr = Graphics.FromImage(src))
                        {
                            gr.Clear(Color.White);
                            gr.DrawString($"({w} {h})", new Font("Arial", 12), Brushes.Black, new PointF(0, 0));
                        }
                        //scrivo il riquadro nell'immagine grande a 1 bit
                        BitmapTo1Bpp(src, finalBitmap, new Rectangle(w* src.Width, h* src.Height, 100, 100));
                    }                    
                }
                finalBitmap.Save("finalBitmap.bmp");
    }


    In questo caso su un immagine di 10000 x 10000 uso dei "quadrati" di 100x100.

    Ho usato un immagine di 10000x10000 per questioni di tempo... infatti elaborare e salvare immagini grandi richiede un sacco di risorse anche solo per aprirlo. Ma se sicuro di volere usare immagini così grandi? é davvero necessario?





    • Modificato U 235 sabato 10 settembre 2022 19:05
    sabato 10 settembre 2022 16:54
  • Ciao  U 235 ,  prima  di  tutto  sempre  grazie  per  l' attenzione .

    Mi  sembra  un  pò  complicato , Per esperienza  propendo  per  le  soluzioni  semplici . L' importante è  conoscere i limiti , così  da  poter  gestire  la  memoria  senza  incorrere  in  un  errore  run-time . Stabiliti i limiti , ci  saranno  messaggi  di  segnalazione  che  certe  ricerche  dovranno  essere  riformulate . Ovviamente  sto  cercando  di  alzare , in partenza , il  più  possibile  questi  limiti .

    La  tua  domanda  :  se  devo  usare  immagini  così  grandi ?    Non  so  nemmeno  SE  DEVO  PROPRIO  USARE  IMMAGINI .

    L' applicazione  svolge  ricerche  su  file-dati  alfanumerici  di  migliaia  di  record  , ognuno  di  una ( o più ) decine di campi .

    Può  utilizzare  valori  selettivi  su  uno  o  più  campi , in tal modo i record possono ridursi  a  qualche  decina o centinaia .

    Alla  termine  il  rapporto  finale  consiste , di  norma , in  un  diagramma  cartesiano ( asse  X , asse Y ) con  istogrammi , seguito  da  un  elenco  di  righe  contenenti  dati  formattati  stile  colonne .  Il  tutto  salvabile  su  disco  e/o  stampabile .

    Non  so  se  usare  bitmap + Graphics  è il metodo  migliore per fare  tutto  questo . Non  ho  motivo  di  scartare  soluzioni  alternative .

    domenica 11 settembre 2022 08:34
  • Alla  fine  ho  trovato  che  utilizzo    .NET Framework 4.6.1 
    domenica 11 settembre 2022 10:12
  • Onestamente non credo sia la strada migliore per fare i report... a limite potresti fare il grafico e tutte quelle cose puramente visuali con le immagini (qrcode; barcode; planimetrie ecc.), infatti è il loro lavoro. Ma quello che stai facendo tu sono dei "report", e per farli ci sono strumenti migliori. Fermo restante poi lo scopo per cui lo fai, delle volte le cose si fanno non tanto per il risultato finale, ma per puro divertimento, per studio, per curiosità o semplicemente perché... si possono fare! (motto degli ingegneri XD) Non sta certo a me ne a ad altri giudicare questo.

    Hai pensato ad usare pdf? ok, posso capire che non vuoi i report tradizionali, quelli non piacciono nemmeno a me anche se sono molto comodi, ma almeno potresti sfruttare tanti strumenti che mettono a disposizione.

    Dai un occhiata a iTextSharp, si tratta di una libreria che ti consente di creare pdf in maniera abbastanza facile. Impaginazione semplice, posizionamento degli elementi facile, peso minore e quindi risorse minori da sfruttare, fruizione semplificata (visto che l'utente ha strumenti dedicati per lo scopo) ecc. C'é solo da studiare un attimino come funziona, per il resto è semplice.

    domenica 11 settembre 2022 13:26
  • Ciao  U235 ,  ho  provato , per  curiosità , a  scaricare   iTextSharp  .  Non  ci  sono  riuscito  per  due  motivi  fondamentali :

    1. ignoro , quindi  trovo  difficoltà  che  potrei , forse , superare  con  parecchio  impegno
    2. le  applicazioni  che  osservo , e  a  volte , utilizzo  , sembrano  tutte  fatte  con  mattoncini ( oggetti ) prefabbricati . Con  buona  pace  per  la  finalità  principe , che  ogni  strumento  informatico  dovrebbe  avere : essere  al  servizio ( user - friendly )  e  non  quello , che  mi  sembra  attuale , di  costringere  l' utente  ad  adattarsi  all' applicazione .

    Al  dunque , grazie  anche  alle  tue  considerazioni , sono  giunto  alla conclusione  che  se  non  è  facilmente  migliorabile , l' applicazione  va  bene  anche  così  com'è . Nella  realtà  dell' utilizzo , i  limiti  che  ho  incontrato , sono  abbastanza  ampi . Grafici  più  capienti  diventerebbero  comunque  più  difficilmente  gestibili  sia  in  termini  di  stampa  che  nella  visione  con  scrolling  orizzontali e verticali ( parecchio  lenti ) .

    Confido  nel  progresso . Cinquant'anni  fa , quando  ho  iniziato ( anni '70 ) sulla  fatturatrice Olivetti Audi A5 il linguaggio  era  di  tipo  assembler . L' unica memoria disponibile era costituita  da schede magnetiche che in 256 bytes  dovevano  contenere  programmi e dati .

    Poi  sono  arrivati :  IBM 5110 ed Olivetti M24 ed i linguaggi ( dopo un passaggio flash  di  Basic )  il Turbo Pascal della Borland ed infine il C .

    lunedì 12 settembre 2022 08:53
  • Vittorio, buongiorno, 

    Chiederei che capisca una cosa. Il forum MSDN e costrito in tal modo, che ogni domanda dovrebbe contere un problema singolo - non tanti. 
    Per lei, esssi sono conessi, visto che si tratta di un singolo progetto. Per chiunque che cerca invece, potrebbero non essere. Poi, ci sono 8, 10, 15 e piu' risposte in un thread, che crea un casino. 

    Gentilmente vorrei chiedere, che ogni domanda, non uguale a quella iniziale, venne chiesta in un thread separato.

    Grazie


    • Microsoft offre questo servizio gratuitamente, per aiutare gli utenti e aumentare il database dei prodotti e delle tecnologie. Il contenuto fornito “as is“ non comporta alcuna responsabilità da parte dell’azienda.

    lunedì 12 settembre 2022 09:16
    Moderatore
  • OK  Yordan , capito

    Cercherò  di  essere  più  disciplinato

    ( non  è  intenzionale )

    lunedì 12 settembre 2022 10:55
  • Grazie Vittorio

    • Microsoft offre questo servizio gratuitamente, per aiutare gli utenti e aumentare il database dei prodotti e delle tecnologie. Il contenuto fornito “as is“ non comporta alcuna responsabilità da parte dell’azienda.

    lunedì 12 settembre 2022 12:36
    Moderatore