TechnoReaders.com » designer

Swift 3D PS – 3D Plug-In for Photoshop CS4 Extended

Jigish Thakar — Wed, 11 Mar 2009 18:02:04 +0000

New plug-in brings powerful and easy-to-use 3D toolset to the Photoshop CS4 Extended interface

BOULDER, Colo., March 5 /PRNewswire/ — Today Electric Rain, Inc.(R) announced the release of Swift 3D(R) PS, a new plug-in that adds 3D modeling and animation tools to the Photoshop CS4 Extended authoring environment. The plug-in allows Photoshop users to quickly and easily accomplish simple to advanced 3D tasks without leaving the CS4 Extended interface.

“Swift 3D is already very well known in the Flash community and we’re excited to see it introduced as a plug-in to Photoshop CS4 Extended,” commented John Nack, Principal Product Manager for Photoshop & Bridge at Adobe Systems.

Swift 3D PS incorporates the same intuitive interface and toolset as the full version of Swift 3D, making it a good fit for designers that are new to 3D or want to accomplish simple 3D tasks. It also provides advanced modeling and animation capabilities, including new Boolean operations, for designers who want to delve deeper into 3D or expand the workflow into After Effects CS4.

“Swift 3D PS marks an exciting new direction for our designer-oriented 3D tools,” said Mike Soucie, President of Electric Rain. “By plugging into the world’s most powerful 2D design environment, Swift 3D PS not only simplifies and accelerates common “faux-3D” tasks, but opens the door for some very exciting new design possibilities in Photoshop and After Effects. We expect to see some amazing results.”

Key benefits of Swift 3D PS

Create, bevel and extrude 3D text from any font in seconds.
Quickly draw 2D extrusions or lathe objects with a bezier pen tool.
Import, extrude and bevel existing 2D vector artwork from Adobe Illustrator(R) or Flash(R).
Simplify 3D scene creation with targeted cameras and in-viewport lighting manipulation.
Expands Photoshop’s workflow with After Effects CS4 Live 3D view.
3D objects remain fully editable, even after filters are applied.

Swift 3D PS for Windows is available from the Electric Rain website at http://www.erain.com for $149.00 USD.

Swift 3D PS – 3D Plug-In for Photoshop CS4 Extended is a post from: TechnoReaders.com

Yahoo Re-Launched IndexTools As Its Web Analytics

Jigish Thakar — Mon, 13 Oct 2008 01:42:18 +0000

Yahoo has re-launched IndexTools as Yahoo Web Analytics. IndexTools is a web analytics package which brought in April 2008. Yahoo Web Analytics is an enterprise site analytics tool that provides real time visitor behavior on website. With the powerful and flexible tools and dashboards, it able to provide the marketers and website designer with useful analysis reports that will enhance their visitor experience, increase sales, increase traffic and reduce marketing cost.

The key features and benefits of Yahoo Web Analytics as below:

Executive Dashboards- Able to set the key performance metrics with the customizable executive dashboards.
Custom Report- Pre-defined the reports with the Custom Report Wizard.
Advanced compaign management- Track and optimize your marketing compaigns.
Real Time Segmentation- Able to analyze how different groups of visitors respond to different variables on your site.
Live Cost Analysis- Able to compare search engine price information for help keep revenues in check.
Merchandise Reporting- Able to Identify purchase pattern for promote profitable products.
Senario analysis- Able to analyze visitor paths to reduce customer drop-off
Comparative Reporting- Compare reports from two time period with side by side.
Advanced Path Analysis- Get in depth insight into visitor navigation around the site.
Marketing Workflow Management – Enchance the site monitoring and report management capabilities.

Currently, Yahoo Web Analytics is available in beta version for yahoo partner like developers, advertisers or Yahoo Small Business users.

Original Author: Click Here

Yahoo Re-Launched IndexTools As Its Web Analytics is a post from: TechnoReaders.com

Object Oriented Programming in PHP

Jigish Thakar — Tue, 07 Oct 2008 00:30:14 +0000

This article introduces Object Oriented Programming (OOP) in PHP. I will show you how to code less and better by using some OOP concepts and PHP tricks.
Concepts of object oriented programming:

· Abstract data types and information hiding
· Inheritance
· Polymorphism

The encapsulation is done in php using classes:

class Something {
// In OOP classes are usually named starting with a cap letter.
var $x;

function setX($v) {
// Methods start in lowercase then use lowercase to separate
// words in the method name example getValueOfArea()
$this->x=$v;
}

function getX() {
return $this->x;
}
}

Of course you can use your own nomenclature, but having a standardized one is useful.

Data members are defined in php using a “var” declaration inside the class, data members have no type until they are assigned a value. A data member might be an integer, an array, an associative array or even an object. Methods are defined as functions inside the class, to access data members inside the methods you have to use $this->name, otherwise the variable is local to the method.

You create an object using the new operator:
$obj=new Something;

Then you can use member functions by:
$obj->setX(5);
$see=$obj->getX();

The setX member function assigns 5 to the x data member in the object obj (not in the class), then getX returns its value: 5 in this case.

You can access the data members from the object reference using for example: $obj->x=6; however, this is not a very good OOP practice. I enforce you to set data members by defining methods to set them and access the datamembers by using retrieving methods. You’ll be a good OOP programmer if you consider data members inaccessible and only use methods from the object handler. Unfortunately PHP doesn’t have a way to declare a data member private so bad code is allowed.
Inheritance is easy in php using the extend keyword.

class Another extends Something {
var $y;
function setY($v) {
// Methods start in lowercase then use lowercase to seperate
// words in the method name example getValueOfArea()
$this->y=$v;
}

function getY() {
return $this->y;
}
}

?>
Objects of the class “Another” now has all the data members and methods of the parent class (Something) plus its own data members and methods. You can use:

$obj2=new Something;
$obj2->setX(6);
$obj2->setY(7);

Multiple inheritance is not supported so you can’t make a class extend two or more different classes.

You can override a method in the derived class by redefining it, if we redefine getX in “Another” we can’t no longer access method getX in “Something”. If you declare a data member in a derived class with the same name as a data member in a Base class the derived data member “hides” the base class data member when you access it.

You might define constructors in your classes, constructors are methods with the same name as the class and are called when you create an object of the class for example:

class Something {
var $x;

function Something($y) {
$this->x=$y;
}

function setX($v) {
$this->x=$v;
}

function getX() {
return $this->x;
}
}

So you can create an object by:

$obj=new Something(6);

And the constructor automatically asigns 6 to the data member x. Constructors and methods are normal php functions so you can use default arguments.

function Something($x=”3″,$y=”5″)

Then:
$obj=new Something(); // x=3 and y=5
$obj=new Something(8); // x=8 and y=5
$obj=new Something(8,9); // x=8 and y=9

Default arguments are used in the C++ way so you can’t pass a value to Y and let X take the default value, arguments are asigned form left to right and when no more arguments are found if the function expected more they take the default values.

When an object of a derived class is created only its constructor is called, the constructor of the Parent class is not called, this is a gotcha of PHP because constructor chaining is a classic feature of OOP, if you want to call the base class constructor you have to do it explicitely from the derived class constructor.It works because all methods of the parent class are available at the derived class due to inheritance.

function Another() {
$this->y=5;
$this->Something(); //explicit call to base class constructor.
}

?>

A nice mechanism in OOP is to use Abstract Classes, abstract classes are classes that are not instanciable and has the only purpose to define an interface for its derived classes. Designers often use Abstract classes to force programmers to derive classes from certain base classes so they can be certain that the new classes have some desired functionality. There’s no standard way to do that in PHP but:
If you do need this feature define the base class and put a “die” call in its constructor so you can be sure that the base class is not instanciable, now define the methods (interface) putting “die” statements in each one, so if in a derived class a programmer doesn’t override the method then an error raises. Furthermore you might need to be sure since php has no types that some object is from a class derived from you base class, then add a method in the base class to identify the class (return “some id”), and verify this when you receive an object as an argument. Of course this doesn’t work if the evil programmer oveerides the method in the derived class but genrally the problem is dealing with lazy programmers no evil ones! Of course is better to keep the base class unreachable from the programmers, just print the interface and make them work!
There’re no destructors in PHP.

Overloading (which is different from overriding) is not supported in PHP. In OOP you “overload” a method when you define two/more methods with the same name but different number or type of parameters (depending upon the language). Php is a loosely typed language so overloading by types won’t work, however overloading by number of parameters doesn’t work either.

It’s very nice sometimes in OOP to overload constructors so you can build the object in different ways (passing different number of arguments). A trick to do something like that in PHP is:

class Myclass {
function Myclass() {
$name=”Myclass”.func_num_args();
$this->$name();
//Note that $this->$name() is usually wrong but here
//$name is a string with the name of the method to call.
}

function Myclass1($x) {
code;
}
function Myclass2($x,$y) {
code;
}
}

With this extra working in the class the use of the class is transparent to the user:

$obj1=new Myclass(’1′); //Will call Myclass1
$obj2=new Myclass(’1′,’2′); //Will call Myclass2

Sometimes this is very nice.

Polymorphism is defined as the ability of an object to determine which method to invoke for an object passed as argument in runtime time. For example if you have a class figure which defines a method draw and derived classes circle and rectangle where you override the method draw you might have a function which expects an argument x and then call $x->draw(). If you have polymorphism the method draw called depends of the type of object you pass to the function. Polymorphism is very easy and natural in interpreted languages as PHP (try to imagine a C++ compiler generating code for this case, which method do you call? You don’t know yet which type of object you have!, ok this is not the point). So PHP happily supports polymorphism.

function niceDrawing($x) {
//Supose this is a method of the class Board.
$x->draw();
}

$obj=new Circle(3,187);
$obj2=new Rectangle(4,5);

$board->niceDrawing($obj); //will call the draw method of Circle.
$board->niceDrawing($obj2); //will call the draw method of Rectangle.

?>
Some “purists” will say PHP is not truly an object oriented language, which is true. PHP is a hybrid language where you can use OOP and traditional procedural programming. For large projects, however, you might want/need(?) to use “pure” OOP in PHP declaring classes, and using only objects and classes for your project. As larger and larger projects emerge the use of OOP may help, OOP code is easy to mantain, easy to understand and easy to reuse. Those are the foundations of software engineering. Applying those concepts to web based projects is the key to success in future web sites.

Advanced OOP Techniques in PHP
After reviewing the basic concepts of OOP I can show you some more advanced techniques:

Serializing
PHP doesn’t support persistent objects, in OOP persistent objects are objects that keep its state and funcionality across multiple invocations of the application, this means having the ability of saving the object to a file or database and then loading the object back. The mechanism is known as serialization. PHP has a serialize method which can be called for objects, the serialize method returns a string representation of the object. However serialize saves the datamembers of the object but not the methods.
In PHP4 if you serialize the object to string $s, then destroy the object, and then unserialize the object to $obj you might still access the object methods! I don’t recommend this because (a) The documentation doesn’t guarrantee this beahaviour so in future versions it might not work. (b) This might lead to ‘illusions’ if you save the serialized version to disk and exit the script. In future runs of the script you can’t unserialize the string to an object an expect the methods to be there because the string representation doesn’t have the methods! Summarizing serializing in PHP is VERY useful to save the data members of an object just that. (You can serialize asociative arrays and arrays to save them to disk too).

Example:

$obj=new Classfoo();
$str=serialize($obj);
// Save $str to disk

//…some months later

//Load str from disk
$obj2=unserialize($str);

?>
You have the datamembers recovered but not the methods (according to the documentation). This leads to $obj2->x as the only way to access the data members (you have no methods!) so don’t try this at home.
There’re some ways to fix the problem, I leave it up to you because they are too dirty for this neat article.
Full serialization is a feature I’d gladly welcome in PHP.

Using Classes to Manipulate Stored Data

One very nice thing of PHP and OOP is that you can easily define classes to manipulate certain things and the call the appropiate classes whenever you want. Suposse you have a html form where the user selects a product by selecting it’s product ID, you have the data of the products in a database and you want to display the product, show its price, etc etc. You have products of different types, and the same action might have different meanings for different kind of products. For example showing a sound might mean playing it while for some other kind of products might mean to display a picture stored in the database. You might use OOP and PHP to code less and code better:
Define a class product, define which methods the class should have (example display), then define classes for each type of product which extends the product class (class SoundItem, class ViewableItem, etc…) override the methods you define in product in each of this classes make them do what you want. Name the classes according to the “type” column you store in the database for each product a typical product table might have (id,type,price,description,etc etc)… Then in the processing script you can retrieve the type from the database and instanciate an object of the class named type using:

$obj=new $type();
$obj->action();

?>

This is a very nice feature of PHP, you might then call the display method of $obj or any other method regardless the type of object you have. With this technique you don’t have to touch the processing script when you add a new type of object, just add a class to handle it. This is quite powerful, just define the methods all objects regardless of its type should have, implement them in different ways in different classes and use them for any type of object in the main script, no ifs, no 2 programmers in the same file, eternal happiness. Do you agree programming is easy, mainteinance is cheaper and reusability is real now?
If you command a group of programmers is easy to divide the tasks, each one might be responsable for a type of object and the class that handles it. Internacionalization can be done using this technique, apply the proper class according to a language field selected by the user, etc.
Copying and Cloning
When you create an object $obj you can copy the object by doing $obj2=$obj, the new object is a copy (not a reference) of $obj so it has the state $obj had in the moment the assignment was made. Sometimes you don’t want this, you just want to create a new object of the same class as obj, calling the constructor of the new object as if you had used the new statement. This can be done in PHP using serialization and a base class that all other classes must extend.

When you serialize an object you get a string which has a certain format, you may investigate it if you are curious, one of the things the string has is the name of the class (nice!) you may extract it using:

$herring=serialize($obj);
$vec=explode(‘:’,$herring);
$nam=str_replace(“\”",”,$vec[2]);

?>
So suposse you create a class “Universe” and force that all classes must extend universe, you can define a method clone in Universe as:

class Universe {
function clone() {
$herring=serialize($this);
$vec=explode(‘:’,$herring);
$nam=str_replace(“\”",”,$vec[2]);
$ret=new $nam;
return $ret;
}
}

//Then:

$obj=new Something();
//Something extends Universe !!
$other=$obj->clone();

What you get is a new object of class Something created the same way as using new, the constructor is called, etc. I don’t know if this is useful for you, but the Universe class which knows the name of the derived class is a nice concept to experiment. The only limit is your imagination.
…

Object Oriented Programming in PHP is a post from: TechnoReaders.com

Object Oriented Model – a summary of changes from PHP4 to PHP5

Jigish Thakar — Sat, 04 Oct 2008 03:38:33 +0000

What are the differences between the Object Oriented model in PHP5 and PHP4?

Firstly (and the reason the release number jumped) is that assignments copy references in PHP5 (which is regarded as correct OO behaviour) but they duplicate or clone the object in PHP4. This may sound a bit obtuse, but:
* if you duplicate an object and then change one of the copies, you do NOT effect the data refered to by the other name (PHP4 behaviour)
* if you copy by reference (PHP5 behaviour, in effect giving the object a second name) and then change one of the “copies”, you effect both as there one and the same.
In effect, it’s the difference between letting someone share a piece of paper with you and both writing on it (PHP5), and taking a photocopy to give to someone then each writing on your own sheet (PHP4).

The second major difference is that PHP5 lets you use a whole lot of RESTRICTING keywords in your definitions of classes and methods. You can declare that functions and member variables are:
* private – i.e. only visible inside the class
* protected – i.e. only visible in the class or its subclasses
* final – i.e. cannot be overridden by / in subclasses
And you can declare classes to be
* abstract – i.e. MUST be subclassed with specific extra methods
* to implement an interface – i.e. MUST define certain methods

None of these new keywords adds new capabilities, apart from the capability of restricting, so why are they there? To allow the designer / author of a class to limit the externally available elements leading to a crisper, easier to documuent and maintain API (application programmer interface), in the long term interest of maintainable PHP code in substantial applications. If you want a member to be public, you can still use the var keyword of PHP4, although you’re really encouraged to use the public keyword that means the same thing and, you’ll note, does NOT restrict.

Thirdly, in PHP5 you can name your constructor method __construct rather than have it as a function with the same name as the class, and you can use a parent:: notation to call up methods in the base class is you wish to. In this way, you no longer need to code the name of the class, nor its relationship to other classes, internally – once again making for easier code modification and use later. PHP5 also has a __destruct method which is run to clean away objects when you’re finished with them.

Other additions at PHP 5 to the OO model include
* A static keyword to let you define class / static / unbound members
* An autolaod method called if a class is missing at run time
* An __clone method if you really want to duplicate an object
* An __toString method that lets you define what’s printed out when you print or echo an object variable

Original Author : Click Here

Object Oriented Model – a summary of changes from PHP4 to PHP5 is a post from: TechnoReaders.com

TechnoReaders.com » designer

Swift 3D PS – 3D Plug-In for Photoshop CS4 Extended

Related Posts:

Related Posts

Yahoo Re-Launched IndexTools As Its Web Analytics

Related Posts:

Related Posts

Object Oriented Programming in PHP

Related Posts:

Related Posts

Object Oriented Model – a summary of changes from PHP4 to PHP5

Related Posts:

Related Posts