Starting with Poser 7, it is not longer possible to run two or more Python scripts in parallel. This means, all scripts used to communicate with other running programs will disturb Poser. Even Posers Wacros are just scripts and want work anymore, if a communication script runs in the background.

To find a way out of this dilemma, I developed a method to manage this. The most important part is a library that, once loaded, replaces Posers library with an own library („import poser“ is catched and redirected if another script is started). This library is mainly used to catch calls to Posers Python lib a script commonly does, calls a „wakeup“ function in the communication script, and then calls the original Poser function.

The only drawback is, that script shouldn't be started with standard Poser functions to make it work properly. So don't use Posers menu, but the button „Run Poser-Python Script“ or „Run Wacro“. The normal start procedure wan't work, because Poser does not use Python's „execfile“ but an own function build-in into Poser.

Because most of Poser-calls are „catched“, it is also possible to have a sort of debugging (see demo: Switch debug on and start another script using „Run Poser-Python Script“).

Another advantage is, that Poser events are also catched and managed. So, several scripts running in parallel may use the same sort of events.

This package includes

• PPmaster.py, the library to „replace“ Poser calls and to start another script in parallel

• UDPserver.py, a library (with Demomode) to be able to communicate with Poser via UDP.

PPmaster.py

This library may be used for several reasons. To understand what it does, we have to understand how Poser-Python works.

If Poser is started, the „build-in“ Python interpreter is also started and initialized. This Python interpreter is a modified version, so some standard libs want work (threads, for example).

With Poser version 7 (and up), even the method how scripts are executed has changed. Insteed of using Pythons standard function „exec“, an internal exec-function is called by Poser to run a user-written script. This Poser exec function makes sure that only one script is running. Means: it is impossible to have a script running in the background and starting another script in parallel. Maybe this is good for Poser, but this is not so good for a lot of Python scripts used by Poser users.

One of the examples where it makes sense to have a script running in background is communication with the „outside world“. Mostly done with RPC-like scripts (RPC = Remote Procedure Call). This is a method to have one or more applications able to communicate with a server (or another app running on the same machine).

Library PPmaster.py, once started, is using Pythons flexibility to stay between the standard poser library and a running Python script (a script running after lib PPmaster.py is loaded). This is done by overloading the import lib „poser“ with lib „PPmaster.py“ and loading the original poser library with another name. If a script now calls a function from the standard poser library, actually PPmaster.py ist called. If no method or variable is defined for the request the script has made in „PPmaster.py“, the request is send to the original poser library. This is how it basically works.

Note: If a script is started with Pythons original exec-function, the started script should use „PPmaster“ insteed of „poser“ after „import poser“ is executed. That means, a script must know nothing about „PPmaster“ but is controlled by this lib.

But this is not the case if a script is started via Posers standard menus to execute a script if you're using P7 or greater. In this case, Poser starts your script with his own function. So, to use „PPmaster.py“ successfully, you have to use something like a „program-loader“ (you can find a sample in „UDPserver.py“ included in this package).

This is the sourcecode to lib Matnode5 (see a few entries below for description).

Sorry, but I have had no time to extend this further at the moment. If you find error or quirks please feel free to contact me.

Script to generate a nice HTML-Documentation directly from Poser-Python library (doc-strings).

This script is pretty small and easy to extend to your own needs.
Start this script from Poser. Make sure you have a figure in your current scene, because the script needs a "handle" to inspect the "figure()" object.
Output is written to file "poserdoc.html".

This is a Windows EXE file for users not familar with installing Python and Python-libs.
Move the contained EXE-file in any folder you like. No installation required.

Script to resize selected images from a directory to a certain size. Images smaller than the given maxX/maxY are not affected.
ATTENTION: This script needs Python library "Image" from Pythonware! Downwload: http://www.pythonware.com
Because installation of modules may become an adventure with Poser-Python, I advise to install standard Python first (http://www.python.org). This does not affect Poser-Python! For those not familiar with this, download the EXE above.

In the dialog, enter the max sizes for X and Y your images should have. Select if images should be replaced (Yes) or saved as R_oldimagename ("R_" in front of the old name) (No).
Click the button, navigate to the image folder and select all images you like to resize (use left-click, ctrl-left-click or Shift-left-click to select/deselect).

Please Note: Exif-Tags are removed if present. Nearly all imageformats are supported, but there may be probleams with PSD-files (Adobe).

Updated and extended: 07/06/2008
Some bugfixes.
XML-support (MatNodesXML.py) added in a seperate class based on MatNode5. DOM-support with standard Python lib dom.minidom.
Usage is simple:

exportXML( <openfile> ) exports all nodes into the given file in XML-format.
exportPartialXML( <openfile>, nodename ) exports a certain node including it's children.
importXML( <openfile> ) imports all nodes from the given file to your Poser Material-Room.

This library is able to make your life easier if you have to deal with Posers shadernodes in Python, escpecially if you produce Wacros. The complete library is object-oriented. Means, you have to deal with classes, inheritance and things like this.

ATTENTION: There is only a pre-compiled Python library for Poser 7/Pro in this package! Source code may be available if the library is finished.

Feedback of any kind is very appreciated. Please go over to Renderosity and write a private mail to user adp001.

To get a picture, look at the following sample:

					
	turbulence=self.node(T.TURBULENCE,
                             x_scale=8,
                             y_scale=8,
                             z_scale=8,
                             Octaves=2,
                             Bottom=0,
                             Bias=0.5,
                             Gain=0.5)
				

        snow_percent=self.node(T.N,x=0,y=0.5,z=0)
        
        Math1=self.Math(M.Add,   (snow_percent,1.3), (turbulence,0.1))
        Math2=self.Math(M.Add,   (Math1, 20.0), -2)
        Math3=self.Math(M.Clamp, (Math2, 1.0), 0)
        Math4=self.Math(M.Step,  (Math3, 1), 0.001)
        Math5=self.Math(M.Add,   1.0,(Math4, -1.0))				
				

        bl=self.node(T.EDGEBLEND,
                     Inner_Color=1,
                     Outer_Color=2)
        
        normal=self.node(T.N, x=0,z=0)
        
        first_row=bl+5-(bl*(2*normal))
        
        self.node(T.MATH,
                  Math_Argument=M.Sin,
                  Value_1=normal*3+first_row-1,
                  SetName="Sinus"
                  )
				
				

Because it is too mutch to decribe here, download the description I just started. Description is not ready yet (means, not everything is completly described) and I'm really busy adding new functions/methods/classes.
There are a few samples in the package, with debugging switched on. This creates a lot of lines to inform you what's going on if the demo-scripts are executed. Just start each demo from within your Poser (load a figure or a prop first).

After starting this a connection is made to the local Poser server (change the IP-address/Port in the soure to connect to any other server). There are 2 windows: One for what comes from the Poser server (status messages, error messages or answers to your questions) and one (below the other) to insert what should be send to the Poser server after you pressed <Return>.

Bugfix and small extensions. See version below for description

NUDITY at the bottom of this description (Image for demonstration)

Stand alone Python 2.5 app based on Tkinter and using PIL to get more out of your Poser Images.

The main reason to write this script was the poor image quality of most Poser images. This version is a quick first hack for those people that likes to see what they do (original is a command line utility for batch processing written several years ago). It's using only Tkinter and PIL to avoid compatibility problems.

IT'S FAST - but please, don't use it from within Poser - use a standalone Python interpreter

On an todays avarage computer the script works very fast. Even with larger images!

Features

• Gamma correction for each of R, G and B seperately
• Brightness control
• Contrast control
• Color intensity control

Short description:

Make sure you have Python 2.5 and PIL installed. You can download both from Python.org (Python) and Pythonware.com (PIL)

Copy the content from this ZIP file to a folder of your choice. If you've installed Python correctly, a doubleclick on PoserImage.py will start this app.

On the first start, the app appears on a random screen position with a more ore less random size. If you change the position and/or size, it will appear on exactly the same position on the next run.

To load an image, click New or Add from the toolbar. Select the file you want to work with in the upcomming dialog. The path you last used is saved between sessions, so you probably have to navigate only for the first time you select a file.
Wait a second until this image is loaded.

The difference between New and Add is, that with Add previously loaded images are kept. If you press and hold the left mousebutton onto an image, you may move it around. With this you are able to load overlays (for a copyright notice for example).

Press the right mousebutton on a loaded image to see a small submenu popping up.
From this submenu, you may send the selected image up or down, or, most important, can select an Image Operation dialog.

If you click ok in the dialog, all changes are taken over to the selected image. If you click cancel, nothing is changed.
Please note that all parameters you entered are saved between sessions (except if you've pressed cancel).

Image Operation

Use the dials to change values. If you release the mousebutton, the image will be changed to the new values.
(The dials doesn't work optimal - release the mouse and start again; if you find the trick how to do it better, just drop me a mail)

To insert values directly, point your mouse to one of the inputfields. Change the value and press Return.

Please keep in mind that this script is Work In Progress. Please give feedback, critique, talk about what you want to see. And if you somebody is willing and able to make a better description: be my guest! I'm a german with a lot of problems while writing english :(

Here is a sample - V4 standard texture (all texturefiles gamma corrected), slightly modified shader, 2 lights.
The one to the right is Poser unmodified, the left one is slightly corrected with this script.

Class to connect and communicate with one or more Poser servers running CommServerLib or PoserEvalServer.

The main class primarely has 2 functions:

• Initialising/connecting to a server
• Sending a question, receiving and returning an answer

The second class in this script is a threaded version. With this one is able to hold connections to as mutch Poserservers as needed, all to the same time.

After starting this a connection is made to the local Poser server (change the IP-address/Port in the soure to connect to any other server). There are 2 windows: One for what comes from the Poser server (status messages, error messages or answers to your questions) and one (below the other) to insert what should be send to the Poser server after you pressed <Return>.

See version 1.7 for description

Now able to run outside of Poser. May be usefull for testing.

This is a "server" listening on localhost, Port 8080, made to be used as a class for your own projects.

DEMO INCLUDED:
Just starting the script from within Poser results in a Python command prompt similar to a standard Python shell. You may reach your Poser Python shell while using telnet to make a connection to localhost:8080.

Study the well documented sourcecode to get a picture of what is possible with this script.
Beside of using this as a Python shell for Poser, this script is primarily usefull as a basic class to do IPC (Inter Process Communication) with Poser.

Because Windows telnet seems not to be a real standard telnet client, you probably want to install a fully functional telnet (and ssh client). Small, fast and full of features.
Download from PuTTY Downloadpage

Yes, I'm a bit proud that I could make this possible :)
And, you wouldn't believe it until you see it: it's very small!
What this class does is best shown with this image to the left.

The dials behave in a similar manner as the well known Poser dials do.
Your may display the dials with different sizes, if you wish.
Handling is very simple: Just use it as you do with other standard Tk-widgets. It has some special keywords, all well documented in the source.
There is no need to hold each dial in an array or something like this to get the values, because a special virtual event is fired if a value is changed. So, just inspecting the event-parameter "ev.widget" tells you which dial is updated.

If you run this script with Poser-Python, you must make sure that the images are in the same folder the script is located. A script running with Poser Python has no chance find the path themself. *
After a quick test it assumes that Poser 7 and ImageTk.Photoimage are no friends. Poser 7 dies silently on my machine.

Please note: This class is using PIL from effbot.org for the required images and image manipulation.

There is a small demo app at the end of the source to show how to use it.

To see it work start the script and let the mouse rest over the widgets.

Sometimes you may need more features with a dialog - Tkinter is complicated, without bells and wistles, and not available on Macs (Tkinter from Poser 7 and OS-X works!).

If you are familar with HTML, what about creating a full featured webpage (including Javascript) to design your dialogs?

This little scripts shows you how to do it. It is using CommServerLib to do the basics.

This script creates and starts a little webserver listening on port 8080. The webserver knows only GET requests. If a GET request (from a webbrowser) comes in, it looks for submitted data and collect this data in a dictionary named query. The requested page is delivered to the Browser if the page could be found.

If the magic page DATA (no extension) is requested, the script assumes this was the last page and stops.

This script is a nice startpoint to create your own Poser Application Server!

An index.html file is included. Unzip this scriptpackage to the same folder where CommserverLib resides.
Start the script (nothing seems to happen in your Poser - you may still use it) and start your webbrowser.
Request http://127.0.0.1:8080 and the contained index.html will be shown. Enter something into the input fields and hit submit. The Poser Python Console window will show what you left into the input fields.
The script has stopped, so if you want to try again, you have to re-start the script.

Should work with P5/P6/P7.

A really simple dropdownlist as a class (quick hack).

Start the script (from Poser Python or stand alone) to checkout how it looks. But make sure you have ADPPoserConsole also available, because it's using class App to hold the demo simple to read.

To use it in your own script, write

          from ADPDropdownList import DropDown
          DropDown( master, width=25)
        

Or copy the class directly into your script and use it like other widgets.
Please note: All parameters except width are handed over to the Frame widget wrapping the Entry and Button Widget.

Tested with P5/P6/P7.
No real description available yet. Study source.

After starting the script, a small "Application Window" and a Console Window will pop up.
Use the bottom part of the Console Window to insert any Python commands (even whole scripts).

Pressing SHIFT-Enter will execute what is contained in the input window (from first line to last line). Output is shown in the upper window.
Pressing CTRL-Enter will execute the actual line only (line where the cursor is located).

All Error or other outputs are redirected to the upper part of the Debug Window.

DON'T FORGET TO CLOSE THE STANDARD POSER PYTHON OUTPUT WINDOW

SIDE-EFFECT: Poser needs less resources in idle-mode if this script is running. See your task manager to check CPU-cycles. Should be (close to) 0% if Poser isn't busy with rendering.

You may start any script by typing: execfile( scriptname )

Poser Python does not allow the installastion of standard Python Packages with Windows, because Poser didn't register Python correctly. So no Windows installer is able to find your Poser Python.

This little script creates a file in your Posers main directory named poserpython-[version].reg (where [version] is Pythons version number, depending on which Poser Version you have installed.
After creating this litle file (you may check it using a normal text editor), make sure your Poser is closed and simply doubleclick poserpython-[version].reg to create the registry entries Poser Python needs.

A class lib to read Poserfiles. Subclass this lib. You'll find plenty descriptions in the sourcecode.

A complete script to extract joint parameters is included as a demo.

Source not included

Using the DAZ method for using morphs often results in a desaster: The channel a morph is using is also used from another morph. As a result, a user ins't able to have both morphpackages installed at the same time.

With this stand alone program a user becomes able to move/rename morphs.

This package contains a Python script packed as an exe-file. Anything the script needs to execute properly is included into this EXE. Even the required Python interpreter. So you are able to use this program without Poser.

Just doubleclick the EXE and follow the instructions you'll see.

Source not included

Saves Joint Parameters from selected actors of a character as a pose file.

This package contains a Python script packed as an exe-file. Anything the script needs to execute properly is included into this EXE. Even the required Python interpreter. So you are able to use this program without Poser.

Just doubleclick the EXE and follow the instructions you'll see.