ZFX
ZFX Neu
Home
Community
Neueste Posts
Chat
FAQ
IOTW
Tutorials
Bücher
zfxCON
ZFXCE
Mathlib
ASSIMP
NES
Wir über uns
Impressum
Regeln
Suchen
Mitgliederliste
Membername:
Passwort:
Besucher:
4439687
Jetzt (Chat):
43 (0)
Mitglieder:
5239
Themen:
24223
Nachrichten:
234554
Neuestes Mitglied:
-insane-

ZFX
Coding-Foren
Sourcecode-Probleme
Re: Transparenz Wert aus PNG-Datei lesen
Normal
AutorThema
TomCat Offline
Schütze Arsch


Registriert seit:
02.03.2002

Bayern
Transparenz Wert aus PNG-Datei lesenNach oben.
Hallo,

wie kann ich aus einer *.png Datei die Transparenz-Werte erhalten? Letztendlich muss es ja für jeden Pixel einen Transparenzwert geben, und genau diesen will ich haben. Das Ziel ist es die Transparenzwerte einfach in einer separaten Datei zu speichern. Gibts da Programme die das können?

ciao,
TomCat
08.03.2009, 16:41:50 Uhr
Aramis Offline
ZFX'ler


Registriert seit:
14.03.2007

Baden-Württemberg
406712329
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Müsste mit GIMP gehen. PNG laden und dann den Alphakanal extrahieren und als separates File speichern.

Alex
08.03.2009, 17:08:10 Uhr
TomCat Offline
Schütze Arsch


Registriert seit:
02.03.2002

Bayern
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Hallo,

und wo bekommt man dieses Gimp her? Hast Du das schon mal gemacht, also dieses Extrahieren der Alphawerte in eine Datei? Und wie liegen die Werte dann in der Datei vor?

ciao,
TomCat



08.03.2009, 18:17:23 Uhr
FredK Offline
ZFX'ler


Registriert seit:
06.05.2004

Schleswig-Holstein
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
GIMP gibts kostenlos unter http://gimp.org/. Wie du da allerdings die Alphamap exportieren kannst, kann ich dir nicht sagen. Ich könnte mir höchstens vorstellen, dass du die als Graustufenbitmap vorliegen hast, die du dann einlesen und auswerten kannst. (Weiß=nicht transparent, Schwarz=transparent)


1 Mal gendert, zuletzt am 08.03.2009, 19:26:23 Uhr von FredK.
08.03.2009, 19:20:38 Uhr
www.funex.tk
TomCat Offline
Schütze Arsch


Registriert seit:
02.03.2002

Bayern
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Hi,

mit einem Graustufen-bild hätte ich ja kein Problem. Blöd ist halt, dass es dieses Gimp nur für Linux gibt.

ciao,
Tomcat
08.03.2009, 19:37:04 Uhr
malignate Offline
ZFX'ler


Registriert seit:
12.01.2004

Baden-Württemberg
204188265
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Oder einfach mit libpng das PNG laden, den Alpha Channel extrahieren (einfach jedes 4te Byte in ein Array schreiben) und als Graustufen Bild abspeichern.
08.03.2009, 19:37:49 Uhr
Krishty Offline
ZFX'ler


Registriert seit:
01.02.2004

Nordrhein-Westfalen
342173470
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Möchtest du das automatisch oder von Hand machen?

Falls automatisch, musst du dir libpng, die offizielle Referenzimplementation des PNG-Formats, ansehen.

Falls von Hand, wie gesagt Gimp. Dort gab es eine Funktion Image->Decompose, mit der man ein Bild in seine Kanäle aufteilen konnte. Ist aber schon länger her, kA ob das in der neuesten Version genauso ist.

Gruß, Ky

Edit:
Ups, malignate war schneller. Gimp gibt es übrigens sehr wohl für Windows.

2 Mal gendert, zuletzt am 08.03.2009, 19:40:52 Uhr von Krishty.
08.03.2009, 19:38:12 Uhr
atr_23 Offline
Artwork-Berater


Registriert seit:
16.10.2002

Niedersachsen
107316684
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
da die frage ja eher technisch orientiert ist verschiebe ich den thread mal in sourcecode probleme
08.03.2009, 22:25:20 Uhr
Vault 23
Helmut Offline
ZFX'ler


Registriert seit:
11.07.2002

Deutschland
280083044 helmut4242
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Falls dus von Hand machen willst und ne Quick and Dirty Lösung willst, hier haste eine:
Code:
#define NOMINMAX
#include 
#include 
#include 
#include 
using namespace std;

#pragma comment(lib, \"d3d9.lib\")
#pragma comment(lib, \"d3dx9.lib\")

bool CreateD3DDevice(IDirect3D9** ppD3D, IDirect3DDevice9** ppDevice);


struct LOCKED : D3DLOCKED_RECT
{
    D3DCOLOR GetPixel(int x, int y)const
    {
        return ((D3DCOLOR*)pBits)[y*Pitch/sizeof(D3DCOLOR)+x];
    }
    void SetPixel(int x, int y, D3DCOLOR color)
    {
        ((D3DCOLOR*)pBits)[y*Pitch/sizeof(D3DCOLOR)+x] = color;
    }
};

void main(int cArgs, char** pArgs)
{
    sizeof(krank());
    if(cArgs<3)
    {
        cout<<\"Zwei Bilddateien auf die Exe schieben\"<return;
    }
    cout<<\"Warte\"<//Sleep(10000);

    IDirect3D9* pD3D;
    IDirect3DDevice9* pDevice;
    if(!CreateD3DDevice(&pD3D, &pDevice))
    {
        cout<<\"DX9 nicht gefunden\"<return;
    }
    IDirect3DTexture9* pTex1 = 0;
    HRESULT r = D3DXCreateTextureFromFileExA(pDevice, pArgs[1], D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2,
1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, 0, &pTex1);
    if(!pTex1)
    {
        cout<<\"Konnte \"<return;
    }
    D3DSURFACE_DESC TexDesc;
    int cx, cy;
    pTex1->GetLevelDesc(0, &TexDesc);
    cx = TexDesc.Width;
    cy = TexDesc.Height;

    IDirect3DTexture9* pTex2 = 0;
    if(FAILED(D3DXCreateTextureFromFileExA(pDevice, pArgs[2], D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2,
1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, D3DX_DEFAULT, D3DX_DEFAULT, 0, 0, 0, &pTex2)))
    {
        cout<<\"Konnte \"<return;
    }
    pTex2->GetLevelDesc(0, &TexDesc);
    if(cx != TexDesc.Width || cy != TexDesc.Height)
    {
        cout<<\"Bildgroessen stimmen nicht ueberein.\"<return;
    }
    cout<<\"Bilder geladen: \"<if(FAILED(D3DXCreateTexture(pDevice, cx, cy, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_SCRATCH, &pNewTex)))
    {
        cout<<\"Textur konnte nicht im Arbeitsspeicher erstellt werden.\"<return;
    }

    LOCKED Lock1, Lock2, NewLock;
    pTex1->LockRect(0, &Lock1, 0, 0);
    pTex2->LockRect(0, &Lock2, 0, 0);
    pNewTex->LockRect(0, &NewLock, 0, 0);
    for(int x=0;xfor(int y=0;yif(b.r>w.r || b.g>w.g || b.b>w.b)
        {
            n=b;
            b=w;
            w=n;
        }
        n.a = b.g-w.g+1.0f;
        n.r = b.r / n.a;
        n.g = b.g / n.a;
        n.b = b.b / n.a;
/*        n = b;
        n.a *= 5.0f;
        n.r*=0.5f;
        n.g*=0.2f;
        n.b*=1.2f;*/
//        n.a = std::min(b.a*3.0f, 1.0f);
        NewLock.SetPixel(x, y, n);
    }

    pTex1->UnlockRect(0);
    pTex2->UnlockRect(0);
    pNewTex->UnlockRect(0);

    char Buffer[1024];
    int len = GetModuleFileNameA(0, Buffer, 1024);
    for(int i=len-1;i>=0;i--)
        if(Buffer[i]=='')
        {
            Buffer[i+1] = 0;
            break;
        }
    strcat_s(Buffer, 1024, \"NeuesBild.png\");

    if(FAILED(D3DXSaveTextureToFileA(Buffer, D3DXIFF_PNG, pNewTex, 0)))
    {
        cout<<\"Bild konnte nicht gespeichert werden.\"<return;
    }


    pNewTex->Release();
    pTex2->Release();
    pTex1->Release();
    pDevice->Release();
    pD3D->Release();
}


bool CreateD3DDevice(IDirect3D9** ppD3D, IDirect3DDevice9** ppDevice)
{
    *ppD3D=0;
    *ppDevice=0;
//    *ppDevice=new MyDevice();
    // Create the D3D object, which is needed to create the D3DDevice.
    *ppD3D= Direct3DCreate9(D3D_SDK_VERSION);
    if(*ppD3D==0)
    {
        return false;
    }

    // Set up the structure used to create the D3DDevice. Most parameters are
    // zeroed out. We set Windowed to TRUE, since we want to do D3D in a
    // window, and then set the SwapEffect to \"discard\", which is the most
    // efficient method of presenting the back buffer to the display.  And 
    // we request a back buffer format that matches the current desktop display 
    // format.
    D3DPRESENT_PARAMETERS d3dpp; 
    ZeroMemory( &d3dpp, sizeof(d3dpp) );
    d3dpp.Windowed = TRUE;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

    // Create the Direct3D device. Here we are using the default adapter (most
    // systems only have one, unless they have multiple graphics hardware cards
    // installed) and requesting the HAL (which is saying we want the hardware
    // device rather than a software one). Software vertex processing is 
    // specified since we know it will work on all cards. On cards that support 
    // hardware vertex processing, though, we would see a big performance gain 
    // by specifying hardware vertex processing.

    (*ppD3D)->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, GetDesktopWindow(),
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, ppDevice);
    if(*ppDevice==0)
    {
        (*ppD3D)->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, GetDesktopWindow(),
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                      &d3dpp, ppDevice);
        if(*ppDevice==0)
        {
            (*ppD3D)->Release();
            *ppD3D=0;
            return false;
        }
    }
    return true;
}

Das Programm nimmt zwei png Dateien, die zwei mal das gleiche Bild, einmal auf schwarzem und einmal auf weißem Hintergrund, zeigen und generiert das png mit Alphakanal. (das ist hilfreich, wenn man sich zB transparente Grafiken aus anderen Programmen borgen möchte oder das verwendete Grafikprogramm zu doof ist einen korrekten Alphakanal zu speichern)
Für deinen Fall ist es ja trivial abzuändern.

Ciao
09.03.2009, 12:34:40 Uhr
Bomber-Revolution
Löwe Offline
ZFX'ler


Registriert seit:
29.09.2003

Nordrhein-Westfalen
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
gimp für Windows: http://gimp-win.sourceforge.net/stable.html

... scrollen und lesen hat geholfen

09.03.2009, 18:21:58 Uhr
EyDu Offline
ZFX'ler


Registriert seit:
24.08.2002

Deutschland
224254930
Re: Transparenz Wert aus PNG-Datei lesenNach oben.
Code:
from PIL import Image
im = Image.open(\"test.png\")
red, green, blue, alpha = im.split()
alpha.save(\"out.png\")
10.03.2009, 14:55:16 Uhr
Normal


ZFX Community Software, Version 0.9.1
Copyright 2002-2003 by Steffen Engel