Hi Dan,

I am not sure but I think you could edit the compound for resolving tokens.
The core node does require absolute file paths, I am afraid hardcoding
low-level c++ for resolving tokens might take some time which unfortunately
I do not have right now.

However, it is a good point that I will take into cosideration for future
updates.

Cheers !


On Thu, May 29, 2014 at 5:25 PM, Dan Yargici <danyarg...@gmail.com> wrote:

> Hi Alok.
>
> I'm using this for the first time and loving it, however my immediate crit
> would be that it would be great if it could resolve tokens.  In my case
> [Project Path] specifically.
>
> Thanks again for this!
>
> DAN
>
>
>
> On Sun, Nov 17, 2013 at 9:52 AM, Dan Yargici <danyarg...@gmail.com> wrote:
>
>> Thanks Alok, much appreciated!
>>
>> DAN
>>
>>
>> On Sun, Nov 17, 2013 at 3:01 AM, Alan Fregtman 
>> <alan.fregt...@gmail.com>wrote:
>>
>>> At work we are, yeah. I'll see about getting it compiled.
>>>
>>>
>>>
>>> On Sat, Nov 16, 2013 at 4:16 PM, Alok Gandhi 
>>> <alok.gandhi2...@gmail.com>wrote:
>>>
>>>> Yea it may be that. I presume you are using linux. If not then test out
>>>> the node to check if it works.
>>>>
>>>>
>>>> On Sat, Nov 16, 2013 at 4:01 PM, Alan Fregtman <alan.fregt...@gmail.com
>>>> > wrote:
>>>>
>>>>> Interesting... I wonder if this is why I've been having problems with
>>>>> KP's PC2 reader with huge files just over 2GB? I ended up splitting my
>>>>> meshes to work around it, but now I wonder...
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> On Sat, Nov 16, 2013 at 2:18 PM, Alok Gandhi <
>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>
>>>>>> Hi All,
>>>>>>
>>>>>> I have update the ReadPC2ICE node to version 1.1
>>>>>>
>>>>>> You can find the addon here <http://bit.ly/1axgUea> and code 
>>>>>> here<http://bit.ly/17ZKRpU>
>>>>>> .
>>>>>>
>>>>>> Change Log:
>>>>>>
>>>>>> Bug fixes:
>>>>>>
>>>>>>
>>>>>>
>>>>>> ·         Point data for files over 2 GB was not read correctly due
>>>>>> to limitations of <int> data type. It is changed to <__int64> which can
>>>>>> handle the data > 2 GB. Now the node can easily read files over 2 GB.
>>>>>>
>>>>>>
>>>>>>
>>>>>> *Notes*
>>>>>>
>>>>>> ·         The same changes needs to be applied for
>>>>>> *KP_PointCacheReader* for this bugfix. I am not aware if Kai has
>>>>>> fixed this already in other updates to his code. But the 
>>>>>> one<http://sculptwork.com/rr/bak/kaipirinha/KP_PointCacheV25.zip> I
>>>>>> had from rray.de does not have this change. Kai, if you are
>>>>>> listening can you confirm that?
>>>>>>
>>>>>>
>>>>>>
>>>>>> ·         The code for this bugfix is not supported on Linux.
>>>>>> However, in case you want to compile for Linux, please note that the
>>>>>> <__int64> data type for windows translates to <long long> on a gcc 
>>>>>> compiler
>>>>>> for Linux. I will add support for Linux once I have a machine with Linux 
>>>>>> up
>>>>>> and running. Till then you have to change the code yourself.
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> ·         Suppressed unnecessary warning messages in cases of pc2
>>>>>> file not specified and unable to open file. They were kind of annoying.
>>>>>> Just uncomment my code lines to bring them back if you want.
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> New features:
>>>>>>
>>>>>>
>>>>>>
>>>>>> ·         When working with pc2 files I always missed the ability to
>>>>>> know beforehand the start and end frame of the file. Now the node 
>>>>>> supports
>>>>>> this. There are two new output ports that furnish the start and end 
>>>>>> frames
>>>>>> as scalars. You can use this to do time warps, offsets, view them in
>>>>>> viewports as custom attributes or whatever else you might find it useful
>>>>>> for.
>>>>>>
>>>>>> Please feel free to mail me if you have any question or problems/bugs
>>>>>> with this addon.
>>>>>>
>>>>>> Thanks.
>>>>>>
>>>>>>
>>>>>>
>>>>>> On Mon, Nov 4, 2013 at 9:00 PM, Alok Gandhi <
>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>
>>>>>>> And here is the github for the code:
>>>>>>>
>>>>>>> https://github.com/alok1974/KP_PointCache-Reader-ICE-Node
>>>>>>>
>>>>>>>
>>>>>>> On Mon, Nov 4, 2013 at 8:42 PM, Alok Gandhi <
>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>
>>>>>>>> Here is the code for the pc2 reader:
>>>>>>>>
>>>>>>>> ----------------------------------------------------------
>>>>>>>> """
>>>>>>>> .PC2 File Format:
>>>>>>>> You can create or modify PointCache2 files by hand using the
>>>>>>>> following file format.
>>>>>>>> The start of the file is a header containing:
>>>>>>>>
>>>>>>>> char    cacheSignature[12];   // Will be 'POINTCACHE2' followed by
>>>>>>>> a trailing null character.
>>>>>>>> int     fileVersion;          // Currently 1
>>>>>>>> int     numPoints;            // Number of points per sample
>>>>>>>> float   startFrame;           // Corresponds to the UI value of the
>>>>>>>> same name.
>>>>>>>> float   sampleRate;           // Corresponds to the UI value of the
>>>>>>>> same name.
>>>>>>>> int     numSamples;           // Defines how many samples are
>>>>>>>> stored in the file.
>>>>>>>>
>>>>>>>> Be sure to check the version number. If it isn't 1, then don't mess
>>>>>>>> with the file,
>>>>>>>> as the format will change in the future.
>>>>>>>>
>>>>>>>> Following the header, there is a straight dump of all the cache
>>>>>>>> samples (which are snapshots of all the point positions for an
>>>>>>>> object).
>>>>>>>> Each sample is stored one after the other as a flat array of x/y/z
>>>>>>>> floats
>>>>>>>> for each point (so each sample is (numPoints * sizeof(float) * 3)
>>>>>>>> bytes).
>>>>>>>> """
>>>>>>>>
>>>>>>>>
>>>>>>>> # Note for Alan : You might want to extend this class by adding a
>>>>>>>> method to fetch the frame data
>>>>>>>> #                 for a prticular frame. It is trivial to do so,
>>>>>>>> just look at my code below for
>>>>>>>> #                 getting bounding box data.
>>>>>>>>
>>>>>>>> import os
>>>>>>>> import sys
>>>>>>>> import time
>>>>>>>> from struct import unpack
>>>>>>>>
>>>>>>>> class CacheObject(object):
>>>>>>>>     def __init__(self, pth):
>>>>>>>>         self._dFile = None
>>>>>>>>         self.fPath = pth
>>>>>>>>         self._headerString = ''
>>>>>>>>         self._cacheFileVersionNumber = 0
>>>>>>>>         self._pCount = 0
>>>>>>>>         self._startFrame = 0
>>>>>>>>         self._sampleRate = 0
>>>>>>>>         self._numSamples = 0
>>>>>>>>         self._mshBBox = {}
>>>>>>>>         self._headerRead = False
>>>>>>>>         self._dataRead = False
>>>>>>>>
>>>>>>>>     def _setFile(self):
>>>>>>>>         if not self._dFile:
>>>>>>>>             self._dFile = open(self.fPath, 'rb')
>>>>>>>>             self._msh =
>>>>>>>> os.path.splitext(os.path.basename(self.fPath))[0]
>>>>>>>>
>>>>>>>>         if not self._headerRead:
>>>>>>>>             self._processHeader()
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>     def _processHeader(self):
>>>>>>>>         self._headerRead = True
>>>>>>>>
>>>>>>>>         self._setFile()
>>>>>>>>
>>>>>>>>         dfile = self._dFile
>>>>>>>>
>>>>>>>>         self._headerString = unpack('12s', dfile.read(12))[0]
>>>>>>>>         self._cacheFileVersionNumber = unpack('I', dfile.read(4))[0]
>>>>>>>>         self._pCount = unpack('L', dfile.read(4))[0]
>>>>>>>>         self._startFrame = unpack('f', dfile.read(4))[0]
>>>>>>>>         self._sampleRate = unpack('f', dfile.read(4))[0]
>>>>>>>>         self._numSamples = unpack('L', dfile.read(4))[0]
>>>>>>>>
>>>>>>>>         if not self._dataRead:
>>>>>>>>             dfile.flush()
>>>>>>>>             dfile.close()
>>>>>>>>             self._dFile = None
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>     def _processBBoxData(self):
>>>>>>>>         self._dataRead = True
>>>>>>>>         self._setFile()
>>>>>>>>
>>>>>>>>         dfile = self._dFile
>>>>>>>>         data = {}
>>>>>>>>
>>>>>>>>
>>>>>>>>         s = int(self._startFrame)
>>>>>>>>         e = int(s + self._numSamples)
>>>>>>>>
>>>>>>>>         for f in range(s, e):
>>>>>>>>             xArr = []
>>>>>>>>             yArr = []
>>>>>>>>             zArr = []
>>>>>>>>
>>>>>>>>             for i in range(self._pCount):
>>>>>>>>                 x = unpack('f', dfile.read(4))[0]
>>>>>>>>                 y = unpack('f', dfile.read(4))[0]
>>>>>>>>                 z = unpack('f', dfile.read(4))[0]
>>>>>>>>
>>>>>>>>                 xArr.append((x, i))
>>>>>>>>                 yArr.append((y, i))
>>>>>>>>                 zArr.append((z, i))
>>>>>>>>
>>>>>>>>             # min\max data
>>>>>>>>             d = (max(xArr)[0], max(yArr)[0], max(zArr)[0],
>>>>>>>> min(xArr)[0], min(yArr)[0], min(zArr)[0])
>>>>>>>>
>>>>>>>>             data[f] = { 0:(d[3], d[4], d[5]),
>>>>>>>>                         1:(d[3], d[1], d[5]),
>>>>>>>>                         2:(d[0], d[1], d[5]),
>>>>>>>>                         3:(d[0], d[4], d[5]),
>>>>>>>>                         4:(d[3], d[4], d[2]),
>>>>>>>>                         5:(d[3], d[1], d[2]),
>>>>>>>>                         6:(d[0], d[1], d[2]),
>>>>>>>>                         7:(d[0], d[4], d[2]),
>>>>>>>>                       }
>>>>>>>>
>>>>>>>>         self._mshBBox = data
>>>>>>>>
>>>>>>>>         dfile.flush()
>>>>>>>>         dfile.close()
>>>>>>>>         self._dFile = None
>>>>>>>>
>>>>>>>>     def getHeaderInfo(self):
>>>>>>>>         self._processHeader()
>>>>>>>>         return {'HEADER': self._headerString,
>>>>>>>>                 'VERSION': self._cacheFileVersionNumber,
>>>>>>>>                 'NB_POINTS': self._pCount,
>>>>>>>>                 'START_FRAME': self._startFrame,
>>>>>>>>                 'SAMPLE_RATE': self._sampleRate,
>>>>>>>>                 'NB_SAMPLES': self._numSamples,}
>>>>>>>>
>>>>>>>>     def getBBoxData(self):
>>>>>>>>         self._processBBoxData()
>>>>>>>>         return self._mshBBox
>>>>>>>>
>>>>>>>> if __name__ == '__main__':
>>>>>>>>     f = r'<pc2 file path>'
>>>>>>>>     o = CacheObject(f)
>>>>>>>>     print o.getHeaderInfo()
>>>>>>>>
>>>>>>>> ---------------------------------------------------------
>>>>>>>>
>>>>>>>>
>>>>>>>>  On Mon, Nov 4, 2013 at 8:37 PM, Alok Gandhi <
>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>
>>>>>>>>> Hmm, there are a few options to load the data in reader operator.
>>>>>>>>> Stream, Frame or Memory. Try selecting the frame or memory options. By
>>>>>>>>> default, it is the stream which might have problems similar to one you
>>>>>>>>> have. Anyways, in addition to the ICE Node, few years back, I also 
>>>>>>>>> wrote a
>>>>>>>>> python reader class to read the pc2 file data directly through 
>>>>>>>>> python. Not
>>>>>>>>> optimised using numpy or scipy but it can still let you investigate 
>>>>>>>>> the
>>>>>>>>> contents of a ,pc2 file in a human-readable format. I will also post 
>>>>>>>>> the
>>>>>>>>> code to it.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> On Mon, Nov 4, 2013 at 8:33 PM, Alan Fregtman <
>>>>>>>>> alan.fregt...@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> Intermittent empty frames. Sometimes they work, sometimes not.
>>>>>>>>>> Mind you... it's very dense topo, and the pc2 file is about 2GB. It 
>>>>>>>>>> might
>>>>>>>>>> be reaching some sort of limit somewhere.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> On Mon, Nov 4, 2013 at 8:29 PM, Alok Gandhi <
>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> You do realise that my node is an exact copy of the
>>>>>>>>>>> KP_PointCache Reader Operator. Only difference is that instead of 
>>>>>>>>>>> applying
>>>>>>>>>>> the pointposition on the host mesh posarray, it furnishes the same 
>>>>>>>>>>> data in
>>>>>>>>>>> the vector array format in ICE.
>>>>>>>>>>>
>>>>>>>>>>> I am not sure if reading the pointpositions in ICE through my
>>>>>>>>>>> node will give you any extra functionality that Kai's original 
>>>>>>>>>>> operator
>>>>>>>>>>> can't. But anyways, feel free to try it.
>>>>>>>>>>>
>>>>>>>>>>> Btw, may I know what is the issue that you are having ?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> On Mon, Nov 4, 2013 at 8:25 PM, Alan Fregtman <
>>>>>>>>>>> alan.fregt...@gmail.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> Great! Thank you. Just today we've been experiencing an issue
>>>>>>>>>>>> with KP's reader for this one specific mesh. We're temporarily 
>>>>>>>>>>>> using
>>>>>>>>>>>> Alembic manually, but I'm curious if your reader will be any 
>>>>>>>>>>>> better.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> On Mon, Nov 4, 2013 at 7:45 PM, Alok Gandhi <
>>>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> Surething, will post the source probably on github. My old
>>>>>>>>>>>>> laptop with ubuntu died a few months ago :( so I cant compile it 
>>>>>>>>>>>>> myself.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I will post the link here soon.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sent from my iPhone
>>>>>>>>>>>>>
>>>>>>>>>>>>> On Nov 4, 2013, at 7:20 PM, Alan Fregtman <
>>>>>>>>>>>>> alan.fregt...@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hey Alok,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any chance for a Linux compile? Or sources to attempt a
>>>>>>>>>>>>> compile ourselves?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> On Mon, Nov 4, 2013 at 11:21 AM, Alok Gandhi <
>>>>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Glad it helped you. And yea, now thinking in retrospect, you
>>>>>>>>>>>>>> won't need the switch context as the getpointid already does 
>>>>>>>>>>>>>> that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sent from my iPhone
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On Nov 4, 2013, at 9:23 AM, Cristobal Infante <
>>>>>>>>>>>>>> cgc...@gmail.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> VERY HANDY Alok, I can confirm you don't need the switch
>>>>>>>>>>>>>> context node, all the rest worked fine..
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> By the way, the BIG difference in relation to the default
>>>>>>>>>>>>>>  "Cache on File" read node, is that you are able to move your 
>>>>>>>>>>>>>> cached
>>>>>>>>>>>>>> geometry
>>>>>>>>>>>>>> around the scene. So if you have a last minute layout change
>>>>>>>>>>>>>> you can deal with it in rendering. This is way we've stuck with 
>>>>>>>>>>>>>> KP op
>>>>>>>>>>>>>> reader so far..
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 4 November 2013 13:58, Alok Gandhi <
>>>>>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hi Cristobal,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The node output a single array of pointpositions. So you
>>>>>>>>>>>>>>> have to convert the array to per point attribute. A getpointid 
>>>>>>>>>>>>>>> plugged into
>>>>>>>>>>>>>>> the select in array and them set pointposition will do the 
>>>>>>>>>>>>>>> trick. Of course
>>>>>>>>>>>>>>> you know that the target mesh or pointcloud should have same 
>>>>>>>>>>>>>>> number points
>>>>>>>>>>>>>>> as in the pc2 file. Also you might need a  switch context node 
>>>>>>>>>>>>>>> before set
>>>>>>>>>>>>>>> pointposition.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In case of an empty pointcloud, it is easier. Just plug the
>>>>>>>>>>>>>>> output of the node directly into an add points node.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sent from my iPhone
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On Nov 4, 2013, at 8:13 AM, Cristobal Infante <
>>>>>>>>>>>>>>> cgc...@gmail.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Hi Alok,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thanks again for sharing this tool, we still rely KP pc2
>>>>>>>>>>>>>>> reader so having an alternative is really handy.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I was guessing "Read PC2 File" > "Set Point Position"?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But I am getting a structure mismatch, probably doing the
>>>>>>>>>>>>>>> wrong thing!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thanks,
>>>>>>>>>>>>>>> Cris
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 4 November 2013 05:40, Alok Gandhi <
>>>>>>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ah I see, I was confused when you said " i haven't tried
>>>>>>>>>>>>>>>> multiple files per frame (does softimage even export pc2 files 
>>>>>>>>>>>>>>>> this way?)
>>>>>>>>>>>>>>>> ".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Well in that, sure you can export single file per frame per
>>>>>>>>>>>>>>>> object through KP_PointCache manager, you simply have to 
>>>>>>>>>>>>>>>> select the start
>>>>>>>>>>>>>>>> and end frame as the same. PC2 file format have the notion of  
>>>>>>>>>>>>>>>> "samples"
>>>>>>>>>>>>>>>> rather than frame, so if you have one sample per frame set 
>>>>>>>>>>>>>>>> then basically
>>>>>>>>>>>>>>>> you are exporting one data set (pointpositions) per frame.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On Mon, Nov 4, 2013 at 12:26 AM, Steven Caron <
>>>>>>>>>>>>>>>> car...@gmail.com> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> no one said that you could have multiple objects in the
>>>>>>>>>>>>>>>>> same .pc2 file.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On Sun, Nov 3, 2013 at 8:37 PM, Alok Gandhi <
>>>>>>>>>>>>>>>>> alok.gandhi2...@gmail.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am a little confused...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> For sure, you cannot have multiple objects in the same
>>>>>>>>>>>>>>>>>> .pc2 file, the format simply doesn't support that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> --
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> --
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> --
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> --
>>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>>
>>>>>
>>>>>
>>>>
>>>>
>>>> --
>>>>
>>>
>>>
>>
>


--

Reply via email to