Jump to content
Unity Insider Forum

Aus Unity ein PDF speichern


minuschki

Recommended Posts

Hallo zusammen

Ich habe mit SharpPDF eine A4-PDF Seite erstellt und diese direkt mit Unity als SimplePDF.pdf speichern können. In der Anleitung wird erwähnt, dass die Bilder zuvor in den Unity Projektordner verschoben werden müssen. Dort habe ich neben dem Ordner "Assets" einen Unterordner namens "Bilder" erstellt und "donald1.jpg" und "donald2.jpg" dort abgelegt. Zwei weitere Bilder "fahrzeug.jpg" und "elefant.jpg" befinden sich im Ordner "Assets".

Im Editor funktionierte alles tadellos. Alle Texte und Bilder wurden korrekt in das PDF integriert und gespeichert (im Bild unten die linke Seite).

Das Problem entstand aber beim kompilierten Programm. Zwar wurde ebenfalls ein PDF mit Hilfe von  myDoc.createPDF(System.IO.Directory.GetCurrentDirectory() + "/UnityPDF/" + attacName); in den gewünschten Ordner gespeichert aber leider ohne die Bilder (im Bild die rechte Seite).

Anscheinend werden die Bilder gar nicht mehr gefunden.

Meine Fragen also: Was mache ich falsch? Warum klappt das im Editor-Modus sehr gut und im Standalone-Modus nicht mehr? Was muss eventuell am Pfad geändert werden?

 

Danke für eure Hilfe!

 

 

internal string	attacName = "SimplePDF.pdf";// Name des PDFs

	IEnumerator Start ()
	{
		yield return StartCoroutine (CreatePDF());
	}
	

	public IEnumerator CreatePDF () {
		
		pdfDocument myDoc = new pdfDocument("Sample Application","minuschki", false);
		pdfPage myFirstPage = myDoc.addPage(840,595);
		
		yield return StartCoroutine (myFirstPage.newAddImage ("FILE://Assets/fahrzeug.jpg",20,180,100,100));//Bild aus dem Assets Ordner
		yield return StartCoroutine (myFirstPage.newAddImage ("FILE://Assets/elefant.jpg",320,180,170,255));//Bild aus dem Assets Ordner

		yield return StartCoroutine (myFirstPage.newAddImage ("FILE://Bilder/donald300.jpg",20,280,200,160));//Bild aus dem Bilder Ordner
		yield return StartCoroutine (myFirstPage.newAddImage ("FILE://Bilder/donald72.jpg",200,280,200,160));//Bild aus dem Bilder Ordner

 

SimplePDF.jpg

Link zu diesem Kommentar
Auf anderen Seiten teilen

Danke für deine Antwort!

Ich habe inzwischen auch nochmals intensiv nach einer Lösung gesucht und bin auf folgende Lösung gestossen, die auch funktioniert hat!

Offenbar hat man nach den Build keinen Zugriff mehr auf Dateien, die sich im Assets-Ordner befinden. Daher muss man im Assets-Ordner einen neuen Ordner erstellen, der "StreamingAssets" heisst und in den kann man dann die Bilder hineinlegen. Der neu erstellte Ordner wird dann nach dem Kompilieren in das Build kopiert und kann dann mit Application.streamingPath lokalisiert werden. Von da aus kann man dann Zugriff auf die Bilder.

 

Irgendwo habe ich in einem Forum gelesen:

Wie ein Ressourcen-Verzeichnis kann ein Streaming-Assets-Verzeichnis namens StreamingAssets im Asset-Verzeichnis Ihres Projekts erstellt werden. Im Gegensatz zu Ressourcen-Ordnern bleibt dieses Verzeichnis im Unity-Player intakt und zugänglich. Dadurch wird ein einzigartiger Zugriffspunkt für Benutzer geschaffen, die ihre eigenen Dateien zum Spiel hinzufügen können.

Laut deiner Antwort sollte das Ganze aber auch mit einem Resources-Ordner funktionieren.

 

Ist denn nun meine Lösung auch ok? Funktioniert hat sie auf jeden Fall.

 

yield return StartCoroutine (myFirstPage.newAddImage ("FILE://"+Application.streamingAssetsPath+"/"+"elefant.jpg",320,180,170,255));
//	Bild aus dem StreamingAssets Ordner laden

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

vor 21 Minuten schrieb minuschki:

Danke für deine Antwort!

Ich habe inzwischen auch nochmals intensiv nach einer Lösung gesucht und bin auf folgende Lösung gestossen, die auch funktioniert hat!

Offenbar hat man nach den Build keinen Zugriff mehr auf Dateien, die sich im Assets-Ordner befinden. Daher muss man im Assets-Ordner einen neuen Ordner erstellen, der "StreamingAssets" heisst und in den kann man dann die Bilder hineinlegen. Der neu erstellte Ordner wird dann nach dem Kompilieren in das Build kopiert und kann dann mit Application.streamingPath lokalisiert werden. Von da aus kann man dann Zugriff auf die Bilder.

 

Irgendwo habe ich in einem Forum gelesen:

Wie ein Ressourcen-Verzeichnis kann ein Streaming-Assets-Verzeichnis namens StreamingAssets im Asset-Verzeichnis Ihres Projekts erstellt werden. Im Gegensatz zu Ressourcen-Ordnern bleibt dieses Verzeichnis im Unity-Player intakt und zugänglich. Dadurch wird ein einzigartiger Zugriffspunkt für Benutzer geschaffen, die ihre eigenen Dateien zum Spiel hinzufügen können.

Laut deiner Antwort sollte das Ganze aber auch mit einem Resources-Ordner funktionieren.

 

Ist denn nun meine Lösung auch ok? Funktioniert hat sie auf jeden Fall.

 


yield return StartCoroutine (myFirstPage.newAddImage ("FILE://"+Application.streamingAssetsPath+"/"+"elefant.jpg",320,180,170,255));
//	Bild aus dem StreamingAssets Ordner laden

 

Ja ist sie, ich tu das genauso. Zwar nicht in Bezug auf ein PDF, aber in einigen anderen, sehr ähnlichen Fällen. Ich mache das alles über den StreamingAssets Ordner.

lg

Link zu diesem Kommentar
Auf anderen Seiten teilen

Hallo malzbie

Würde mich dann doch auch sehr interessieren, wie denn die Lösung mit dem Resources Ordner aussehen müsste!

Als ersten Parameter muss ich ja einen string angeben, welcher den gesamten Pfad zum Resources Ordner plus Dateiname enthält.

Mir ist aber nicht klar, wie ich diesen "resourcesPath" herausfinden kann! Ich glaube, da nützt mir eine "var sprite" nicht viel.

 

Wäre sehr nett, wenn du da nochmals helfen könntest!

 

//Load a Sprite (Assets/Resources/elefant.jpg)
var sprite = Resources.Load<Sprite>(elefant);// Weiss aber nicht, was mir das nützen sollte?
  
          
//    Hier müsste doch so etwas Ähnliches stehen wie: "FILE://"+Application.resourcesPath+"/"+"elefant.jpg"
yield return StartCoroutine (myFirstPage.newAddImage ("FILE://"+Application.streamingAssetsPath+"/"+"elefant.jpg",320,180,170,255));

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

So machste das:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class grafiktest : MonoBehaviour
{
    public Material myMat; 
    Texture2D testgrafik;

    void Start()
    {
        testgrafik = Resources.Load("grafiken/testgrafik") as Texture2D;
        myMat.mainTexture = testgrafik;
    }

}

In diesem Beispiel liegt das Script auf einer Plane. Im Inspector ziehe ich das Material in den Slot des Scripts.
Das Mat könnte jetzt schon irgendeine MainTextur haben, oder auch nicht. Ist egal.

Die Textur ist als default Grafik in Unity inportiert worden. Und der Pfad ist Resources/grafiken/  und genau das siehst du ja in der Zeile wo ich die Testgrafik Variable vom Typ Texture2D mit Ressources.Load bestücke.

Natürlich kannst du das auch mit einem Sprite machen oder einer Textdatei. Du braucht eine Variable vom gewünschten Typ und lädst diese mit Resources.Load als gleichen Typ ein.
Oder aber du machst das so wie in den Beispielen, dass du von vonherein gar keine Variable deklarierst, sondern in irgendeiner Funktion/Methode ein undefinierte Variable nutzt.
Diese Variable wird dann zu dem Typ, den du übergeben hast.

var testgrafik2 = Resources.Load("grafiken/testgrafik")as Texture2D;

Und natürlich kannst du auch in beiden Wegen das Resources.Load mit den Spitzklammern <typ> nutzen.

testgrafik = Resources.Load<Texture2D>("grafiken/testgrafik") ;

oder

var testgrafik2 = Resources.Load<Texture2D>("grafiken/testgrafik") ;

  In deinem Script ganz oben rufst du ja eine Coroutine auf wo du auch gleich das Bild mit zusätzlichen Werten lädst. Das Laden brauchst du jetzt nicht mehr, denn die Grafik ist ja schon in der Variable drin. Du musst also die Variable an die Coroutine übergeben.

Soweit klar?

Link zu diesem Kommentar
Auf anderen Seiten teilen

Also, das hat schon mal nicht geklappt!

1. Im Ordner Resources liegt jetzt ein Sprite namens "donald72". Es möchte das gerne mit einem Sprite und nicht mit einer Texture2D machen.

2. Es wird als erstes eine Coroutine aufgerufen, bei der eben ein string erwartet und nicht eine variabel des typs sprite.

3. In anderen Scripts, die ebenfalls aufgerufen werden steht sogar "internal imageElement(Byte[] myImage, int newCoordX, int newCoordY, int imageHeight, int imageWidth)

 

Gibt es denn keine Möglichkeit aus diesem "Resources.Load<Sprite>("donald72")" den Pfad zu ermitteln? Dann könnte ich diesen einfach einsetzen und gut ist. Oder was muss ich sonst ändern, damit es klappt!

 

var testgrafik = Resources.Load<Sprite>("donald72");
yield return StartCoroutine (myFirstPage.newAddImage (testgrafik,200,280));// hier habe ich die variabel "testgrafik" eingesetzt
  // Original steht hier:
  // yield return StartCoroutine (myFirstPage.newAddImage ("FILE://"+Application.streamingAssetsPath+"/"+"donald72.jpg",200,280));
  
  
  
public IEnumerator newAddImage ( string imageName, int X, int Y )// hier wird aber ein string erwartet
	{
		WWW www = new WWW(imageName);
		yield return www;
		addImage(www.bytes,X,Y,www.texture.height,www.texture.width);
	}

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Zeig ersteinmal, was in der Funktion addImage passiert.

Dir muss klar sein, dass ich nicht wissen kann, was in irgendwelchen Funktionen passiert und somit kann ich auch nicht sagen, wie dein Format sein muss.
Ich weiss jetzt schon einmal, dass in der Coroutine WWWForm genutzt wird um das Bild irgendwo her zu laden. Das geht natürlich nur, wenn dieser Pfad und die entsprechende Dateien da drin auch zugänglich sind. Das ist bei einem Build mit dem Ressources Ordner aber nicht der Fall. Es gibt zwar diesen Ordner in deinem Build, aber nicht die Datei so wie du sie gerne hättest.

Sollen die User bei deinem Projekt auch eigene Bilder nutzen können, oder sollen es nur die Bilder sein, die du vorgegeben hast und die in deinem Build schon drin sind?
Das wäre wichtig zu wissen, denn wenn der User da auch eingene Bilder nutzen will, musst du eh irgendwie mit Ordnern außerhalb des Builds arbeiten. Dann wärre WWWform auch ganz toll.
Wenn nicht, dann stellt sich die Frage, ob du WWWForm überhaupt brauchst und in was denn die Bytes codiert werden. Als was passiert da in der addImageFunktion, in die die Bytes rein geschoben werden?!

Link zu diesem Kommentar
Auf anderen Seiten teilen

Sorry, dass ich dich so beanspruche!

Wenn es dir recht ist, lade ich mal das "UnitySharpPDF.zip" hoch. Ich habe das entzippte "SimplePDF.unitypackage" und die beiden Beispielbilder einfach in ein neues Projekt importiert. Danach soll man ein leeres Gameobjekt erstellen und das Script "SimplePDF" dort anhängen. Wenn man dann startet, wird automatisch ein Beispiel-PDF Dokument erzeugt und dieses im Projektordner gespeichert. Das funktioniert aber eben nur im Editor-Modus.

Mein Anliegen wäre, dass sich die Bilder als Sprites, wie von dir vorgeschlagen, im Resources Ordner befinden und dann eben auch in der Build-Version geladen werden. Der User soll die auch nicht sehen oder verändern können.

Noch eine kleine Zusatzfrage: Gibt es eventuell eine Möglichkeit, wie ich vor der Übergabe der Parameter, die Breite und Höhe des Bildes mittels Code ausfindig machen kann? Meine Idee wäre nämlich, diese Werte so direkt als Parameter zu übergeben. 

Wie bereits erwähnt, klappt es mit "streamingAssetsPath", jedoch noch nicht mit der "Resources.Load" Variante.

 

yield return StartCoroutine (myFirstPage.newAddImage ("FILE://"+Application.streamingAssetsPath+"/"+"elefant.jpg",320,180,170,255));

UnitySharpPDF.zip

Link zu diesem Kommentar
Auf anderen Seiten teilen

Ich habe mir das Package mal angeschaut und was bemerkt. Pass auf:

Es gibt da 2 entscheidende Scripts. Einmal das pdfPage Script und dann das imageElement Script.

Im pdfPage so bei Zeile 128 ist die Methode addImage versteckt. Da siehst du , dass adImage gewisse Dinge übergeben haben will. Wie eben auch den String.
Wenn du aber mal runter scrollst, siehst du , dass der Ersteller des Scripts, jede Menge weitere addImage Methoden erstelt hat, die aber alle auskommentiert sind.
Bei Zeile 154 gibt es eine Methode, die keinen String erwartet, sondern ein ImageObject. Diese Methode bräuchtest du und die andeer ( die mit den String) müsstest du dafür auskommenteren.

Damit das Funktioniert musst du so ähnlich bei dem imageElement Script etwas verändern.

Dort erwartet imageElement die Bytes, die vom WWW herkommen würden.

Weiter unten, bei Zeile152, ist aber eine andere Art vorhanden, die eben eine Texture2D will. Das ist genau das was wir wollen!!!
Also auch hier den oberen Internal auskommentieren und den bei Zeile 152 freigeben.

Jetzt musst du nur noch den Aufruf verändern. Du rufst ja momentan noch die Coroutine newAddImage auf, die über WWW ein Bild einlädt. Und wenn's geladen ist, ruft sie wiederum addImage auf um die Bytes zu übergeben. Da du aber keine Bytes mehr hast, sondern direkt eine Texture2D die ja in der Varibale testgrafik gespeichert ist, kannst du direkt das addImage aufrufen. Eine Wartende Coroutine brauchst du nicht mehr.

 

myFirstPage.addImage(testgrafik,X,Y); // hier wird nur die Grafik und die Position im PDF übergeben

So sollte das gehen. Testen werde ich es nicht, da mir son bisschen die Zeit fehlt. :)

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Ich habe das jetzt ausprobiert aber es gibt noch eine Fehlermeldung!

UnitySchnappschuss001.png.ceb5ae7c49f0b008f00029b6d83576ba.png

Im Script "pdfPage" gibt es scheinbar ein Problem mit "newImgObject".

 

Ich kann durchaus verstehen, wenn du darauf aus zeitlichen Gründen nicht antworten kannst! Unter Umständen fehlt aber gar nicht mehr viel.

 

 

 

// Im SimplePDF.cs steht nun: Aufruf
var testgrafik = Resources.Load<Texture2D>("donald72");
myFirstPage.addImage(testgrafik,100,500); // hier wird nur die Grafik und die Position im PDF übergeben
  
  
// Im imageElement.cs steht nun: 
internal imageElement(Texture2D myImage, int newCoordX, int newCoordY)
		{	
			MemoryStream outStream = null;
			try {				
				outStream = new MemoryStream();			
				//myImage.Save(outStream,System.Drawing.Imaging.ImageFormat.Jpeg);
				_content = new byte[outStream.Length];
				_content = outStream.ToArray();				
				//_height = myImage.Height;
				//_width = myImage.Width;			
				_coordX = newCoordX;
				_coordY = newCoordY;
			} catch (System.IO.FileNotFoundException ex) {
				throw new pdfImageNotFoundException("Oggetto Immagine non corretto!", ex);
			} catch (System.IO.IOException ex) {
				throw new pdfImageIOException("Errore generale di IO sull' oggetto immagine!", ex);
			} finally {
				if (outStream != null) {					
					outStream.Close();				
					outStream = null;
				}
			}
		}
  
  
// Im pdfPage.cs steht nun:	•••••••••••••••••• Hier wird aber "newImgObject" beide Male rot unterlegt!
public void addImage( newImgObject, int X, int Y)
		{
			try {
				imageElement objImage = new imageElement(newImgObject, X, Y);
				_elements.Add(objImage);
				objImage = null;
			} catch (pdfImageNotFoundException ex) {
				throw new pdfImageNotFoundException(ex.Message,ex);
			} catch (pdfImageIOException ex) {
				throw new pdfImageIOException(ex.Message,ex);
			}
		}

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Wenn du dir die Zeile 

public void addImage( newImgObject, int X, int Y)

mal anschaust und zwar ganz genau auf die drei Dinge, die da übergeben werden sollen, was fällt dir da auf?
Die Fehlermeldung sagt dir übrigens, dass da ein unerwartetes Symbol auftaucht, nämlich das Komma. Warum ist das unerwartet?

Weil da etwas wichtiges fehlt! Das Komma sollte nämlich noch gar nicht kommen.

Hast du's erkannt?

was ist denn newImageObject? Ich meine bei X und Y ist klar was sie sind. Nämlich int Typen. newImageObject ist aber irgendwie garnix, oder?

Da liegt der Fehler!

Link zu diesem Kommentar
Auf anderen Seiten teilen

Och nö!

Du musst versuchen zu verstehen, was da passiert. Es ist zwar toll, wenn es vorgefertigte Dinge gibt, die man nutzen kann, aber sobald man etwas verändern will/muss, muss man den Code auch verstehen.
Worauf ich hinaus wollte, ist der fehlende Typ von newImageObject. Und zwar muss der ja auch Texture2D sein.
Wenn du eine Methode aufrufst und ihr auch irgendetwas übergeben willst, dann muss die Methode so angelegt sein, dass klar ist was für Typen da kommen und in welche Variable sie gespeichert werden.

Also:

public void addImage( Texture2D newImgObject, int X, int Y)

Trotzdem hast du Recht. Der auskommentierte Code ist fehlerhaft. PDF Elemente werden scheinbar nur als Stream abgespeichert, also Byteweise. Tja, und da wäre für dich noch Einiges zu tun. Ich habe aber scheinbar ne Lösung für das Problem gefunden. Ich melde mich gleich nochmal.

Link zu diesem Kommentar
Auf anderen Seiten teilen

So. Ich habe jetzt den vorhandenen Code soweit geändert, dass auch eine Texture2D geladen UND in die PDF eingefügt werden kann.
Ich erkläre dir, was ich gemacht habe und welche Scripte alle betroffen sind.

4 Scripte müssen bearbeitet werden.

1. pdfPersistentPage.cs

Hier ist, genauso wie bei pdfPages.cs, die Methode addImage zu verändern. Die Version mit Bytes muss weg ( ab Zeile 53) und die Methode mit Texture2D muss frei werden (ab Zeile 72).

Ich weiß jetzt gar nicht mehr, ob da auch das Textures2D fehlte, deswegen poste ich den Abschnitt mal, wie er sein muss.

public void addImage( Texture2D newImgObject, int X, int Y)
		{
			try {
				imageElement objImage = new imageElement(newImgObject, X, Y);
				_persistentElements.Add(objImage);
				objImage = null;
			} catch (pdfImageNotFoundException ex) {
				throw new pdfImageNotFoundException(ex.Message,ex);
			} catch (pdfImageIOException ex) {
				throw new pdfImageIOException(ex.Message,ex);
			}
		}

Vergleiche einfach ob es im Code bei dir genauso steht.

 

2. pdfPages.cs

Das war der Bereich, bei dem ich dich animieren wollte, soelbst den Fehler zu finden:

public void addImage( Texture2D newImgObject, int X, int Y)
		{
			try {
				imageElement objImage = new imageElement(newImgObject, X, Y);
				_elements.Add(objImage);
				objImage = null;
			} catch (pdfImageNotFoundException ex) {
				throw new pdfImageNotFoundException(ex.Message,ex);
			} catch (pdfImageIOException ex) {
				throw new pdfImageIOException(ex.Message,ex);
			}
		}

Da fehlte einfach nur das Texture2D in der void.

3. ImageElements.cs

Hier habe ich einiges abändern müssen, da der Codeersteller versucht hatte, die Bytes des Bildes per System.Drawing zu ermitteln, was aber ga nicht geht, weil in System, gibt es kein Drawing. Ich zeige dir erstmal den Codeabschnitt und erkläre ed dir danach:

internal imageElement(Texture2D myImage, int newCoordX, int newCoordY)
		{	
			MemoryStream outStream = null;
			try {

                byte[] bytes = myImage.EncodeToPNG(); // das hier ist neu um die Bytes zu bekommen.

                outStream = new MemoryStream();
                //myImage.Save(outStream,System.Drawing.Imaging.ImageFormat.Jpeg);
                //_content = new byte[outStream.Length];
                //_content = outStream.ToArray();

                _content = bytes; // das hier ist neu
								
				_height = myImage.height; // hier war ein Height mit großem H
				_width = myImage.width;	// hier war ein Width mit großem W		 
				_coordX = newCoordX;
				_coordY = newCoordY;
			} catch (System.IO.FileNotFoundException ex) {
				throw new pdfImageNotFoundException("Oggetto Immagine non corretto!", ex);
			} catch (System.IO.IOException ex) {
				throw new pdfImageIOException("Errore generale di IO sull' oggetto immagine!", ex);
			} finally {
				if (outStream != null) {					
					outStream.Close();				
					outStream = null;
				}
			}
		}

Um an die Bytes zu kommen, habe ich einen Workarround genutzt. Und zwar nutze ich Texture2D.EncodeToPNG( ) dafür, wie es auch im Beispiel für  WWWForm angegeben war.
diese Info wird dann der _content Variable übergeben. die Variablen _height und _width wollten die werte vom myImage haben, dort wurde Width und Height jedoch groß geschrieben, was es so bei Texture2D aber nicht gibt. Da werden die Parameter klein geschrieben. Das ahbe ich also auch geändert.
Ja und dann habe ich alles, was nicht funktioniert auskommentiert. Siehste ja.

4. SimplePDF.cs

Hier sind die letzten Zeilen des Codes wichtig (ab Zeile70).

Ursprünglich wurde ja die Coroutine myFirstPage.newAddImage() gestartet.
Das hatten wir ja gestern schon auf den direkten Start von myFirstPage.addImage() geändert.
Jetzt habe aber heute erst gesehen, dass dieser ganze Code in einer Coroutine drin steht und eine Coroutine wartet immer auf etwas und will gerne was zurückgeben.
Das tut sie mit dem yield return.
Damit das jetzt hier ohne weiteren Umbau des Codes funktioniert, habe ich einfach auf die testgrafik an sich warten lassen.

Hier der veränderte Code :
 

var testgrafik = Resources.Load<Texture2D>("Picture1");
myFirstPage.addImage(testgrafik, 100, 500); // hier wird nur die Grafik und die Position im PDF übergeben
yield return testgrafik; // da das ne Coroutine ist, muss auch auf was gewartet werden

//yield return StartCoroutine ( myFirstPage.newAddImage (  "FILE://picture1.jpg",2,100 ) );

myDoc.createPDF(attacName);
myTable = null;
Debug.Log("erstellt");

 

Ein Hinderniss gibt es jetzt noch:

Die Grafiken, die im Resources Ordner drin liegen, müssen in den Importeinstellungen auf Read/Writ Eabled gestellt werden und sie dürfen nicht Komprimiert sein.
Nur so, kann er die Bytes auslesen.

Siehe Bild:

1184503983_Anmerkung2020-04-05160619.png.d5f1c36944bf2a3926338d99d232d6a6.png

 

Jetzt solltest du es auch hinkriegen.
Ich habs jedenfalls im Editor und im Build getestet und bei mir geht's.
:)

Link zu diesem Kommentar
Auf anderen Seiten teilen

Mann, das ist ja unglaublich, dass du dir so viel Mühe gibst! Danke vielmal!

Ich habe alles so hineinkopiert, wie du es vorgeschlagen hast. Alles scheint geklappt zu haben, bis auf das Script im "pdfPersistentPage.cs". Hier habe ich ebenfalls dein Scriptvorschlag verwendet, aber das "Texture2D" wird hier nicht akzeptiert (im ImageElements.cs war das "Texture2D" kein Problem).

Und was ist mit dem "IEnumerator new AddImage" im "pdfPage.cs". Der erwartet ja auch einen "string". Muss der drinnen bleiben oder deaktiviert sein?

 

 

UnitySchnappschuss001.thumb.png.db056119893be9f501b4cbc57ee0e892.png

MonoDevelop-UnitySchnappschuss002.thumb.png.5c6217f6e807e2a7fe4f217ba85aa330.png

MonoDevelop-UnitySchnappschuss001.png

Link zu diesem Kommentar
Auf anderen Seiten teilen

Oh ja, hab ich vergessen zu erwähnen.
Du musst in dem pdfPersistentPage ganz oben noch

using UnityEngine;

einfügen. Die Fehlermeldung sagt das ja quasi aus. ;)

Die Coroutine newAddImage kommentierst du komplett aus. Die brauchst du nicht.

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Habe das nun erledigt! Es kommt keine Fehlermeldung mehr und es wird auch ein PDF erstellt, mit Titel und Tabelle, aber ein Bild ist da nirgends zu sehen!

Das Bild liegt im Resources Ordner und ist auf Read/Write Enabled und Compression None importiert worden.

Der Aufruf ist wie du ihn vorgegeben hast!

Link zu diesem Kommentar
Auf anderen Seiten teilen

Tja, dann musst du mal auf Fehlersuche gehen, denn bei mir funktioniert das tadellos.

Als erstes musst du mal deine Bildposition überprüfen. Die Position gibt nämlich die untere linke Ecke des Bildes an. Vielleicht ist dein Bild nicht zu sehen, weil es oben aus dem Blatt herausragt.

Dann setz mal ein Debug.Log in das ImageElement script. Und zwar hier:

internal imageElement(Texture2D myImage, int newCoordX, int newCoordY)
{
  MemoryStream outStream = null;
  try {
    
           byte[] bytes = myImage.EncodeToPNG(); // das hier ist neu um die Bytes zu bekommen.
          //Hier drunter
           Debug.Log("length: "+bytes.Length); 
          //hier drüber
           outStream = new MemoryStream();

Das Debug.Log im simplePDF wo erstellt drin steht haste noch? Wenn ja, dann solltest du das ja auch sehen.

Wenn du als die Szene startest, solltest du diese Dinge in der Console sehen:

console.png.20a01753f959822595e8cc711bb418e5.png

Wenn die length größer als 0 ist, hat er das Bild schonmal geladen und den bytes übergeben.

Ja und "erstellt" sollte auch kommen, denn dann ist er fertig.

Du darfst auch keine Fehlermeldung sehen.

Link zu diesem Kommentar
Auf anderen Seiten teilen

Ja, in der Console sehe ich die genau gleichen Werte und es gibt keine Fehlermeldung.

Ich habe zusätzlich noch mit der Position x und y herumprobiert und verschiedene Werte benutzt. Bei 10 und 400 sollte das Bild doch ca. in der unteren Mitte sichtbar sein. Fehlanzeige!

 

var testgrafik = Resources.Load<Texture2D>("Picture1");
		myFirstPage.addImage(testgrafik, 10, 400); // hier wird nur die Grafik und die Position im PDF übergeben
		yield return testgrafik; // da das ne Coroutine ist, muss auch auf was gewartet werden

 

Link zu diesem Kommentar
Auf anderen Seiten teilen

Archiviert

Dieses Thema ist jetzt archiviert und für weitere Antworten gesperrt.

×
×
  • Neu erstellen...