Convert 3D space to 2D Space



  • On 04/07/2018 at 03:36, xxxxxxxx wrote:

    Hey Everyone,

    Just wanted to know if anyone can point me in the right direction.

    Im looking to convert a 3D (world) space, point co-ordinate into a 2D camera space co-ordinate.

    Is this possible with the python SDK?

    Any info or a nudge in the right direction is much appreciated!

    Cheers,

    Cerac



  • On 04/07/2018 at 12:22, xxxxxxxx wrote:

    Check out the BaseView class
    BaseView::WC() or BaseView::WC_V() is what you most likely are looking for.



  • On 05/07/2018 at 02:12, xxxxxxxx wrote:

    Hi Ceracticus,

    As Daniel already pointed you BaseView.WC and BaseView.WC_V is the way to go.

    Additionally, I would like to point you to the C++ manual which can give you some valuable information even for python.

    Cheers,
    Maxime



  • On 05/07/2018 at 09:53, xxxxxxxx wrote:

    Hey Both,

    thanks so much for your suggestions, massively helpful.

    Managed to get 90% of the way with looking up other examples on this site, plus your feedback which is really great.

    What im essentially doing is rebuilding the interactive render region crop function out of guides (converted from world to screen space) then plugging these values into the active render setting.

    Ive got everything working as expected - apart from when a camera has film offset. I know i can access this data which is great.

    [c4d.CAMERAOBJECT_FILM_OFFSET_Y]```[c4d.CAMERAOBJECT_FILM_OFFSET_X]`

    Does anyone know what the best way of taking this into account whilst running my code?

      
    def main() :  
        
      
      rd = doc.GetActiveRenderData()  
      rd_w = rd[c4d.RDATA_XRES_VIRTUAL]  
      rd_h = rd[c4d.RDATA_YRES_VIRTUAL]  
      bd = doc.GetActiveBaseDraw()       # Get current view  
      sf = bd.GetSafeFrame() #SafeFrame  
      
      obj = op.GetObject()               # Get Null  
      cam = obj[c4d.ID_USERDATA,2]       # Get Camera  
      top = obj[c4d.ID_USERDATA,3]       # GetGuideObjects  
      bottom = obj[c4d.ID_USERDATA,7]  
      left = obj[c4d.ID_USERDATA,8]  
      right = obj[c4d.ID_USERDATA,9]  
      switch = obj[c4d.ID_USERDATA,4]           # Get Switch  
      cZ = cam[c4d.CAMERAOBJECT_TARGETDISTANCE] #z-distance  
      
      if switch:  
      
          # +-------------------------- TOP IRR  
        
          topPos = top.GetMg().off #top global position  
          top_v = bd.WS(topPos) #World2Screen  
        
        
          top_v[0] = (top_v[0] - sf["cl"])/(sf["cr"]-sf["cl"])  
          top_v[1] = (top_v[1] - sf["ct"])/(sf["cb"]-sf["ct"])  
          top_v[2] = (cZ-top_v[2])/cZ  
      
          top_pos = top_v[1] #Gets Y pos from vector  
      
          # Rangemap the result to IRR space  
          irrTop_min = c4d.utils.RangeMap(top_pos, 0, 1, 0, rd_h, True)  
          irrTop_max = 0  
        
          # If its over halfway - reverse it  
          if irrTop_min >= (rd_h/2) :  
              irrTop_max = c4d.utils.RangeMap(irrTop_min, rd_h, rd_h/2, 0, rd_h/2,True)   
              rd[c4d.RDATA_RENDERREGION_TOP] = int(irrTop_max)  
            
          else:  
              pass
    

    Thanks again!

    Cerac



  • On 09/07/2018 at 07:09, xxxxxxxx wrote:

    Hi Ceracticus,

    Actually, WS already take care of the film offset, so you just have to do something like that.

        rd = doc.GetActiveRenderData()
        rd_w = rd[c4d.RDATA_XRES_VIRTUAL]
        rd_h = rd[c4d.RDATA_YRES_VIRTUAL]
        
        bd = doc.GetActiveBaseDraw()
        viewX = bd.GetFrame()["cr"]
        viewY = bd.GetFrame()["cb"]
        sf = bd.GetSafeFrame() #SafeFrame
        cam = bd.GetSceneCamera(doc)
      
        top = doc.GetFirstObject().GetMg().off
        bot = doc.GetFirstObject().GetNext().GetMg().off
        left = doc.GetFirstObject().GetNext().GetNext().GetMg().off
        right = doc.GetFirstObject().GetNext().GetNext().GetNext().GetMg().off
      
    	# Get pixels counts between top obj and the frame, then scale this pixel count according to the ratio between viewport size and render size.
        top_p = max(0, bd.WS(top).y - sf["ct"]) * rd_h / viewY 
        bot_p = max(0, sf["cb"] - bd.WS(bot).y) * rd_h / viewY
        left_p = max(0, bd.WS(left).x - sf["cl"]) * rd_w / viewX
        right_p = max(0, sf["cr"] - bd.WS(right).x) * rd_w / viewX
        
        rd[c4d.RDATA_RENDERREGION_TOP] = int(top_p)
        rd[c4d.RDATA_RENDERREGION_BOTTOM] = int(bot_p)
        rd[c4d.RDATA_RENDERREGION_LEFT] = int(left_p)
        rd[c4d.RDATA_RENDERREGION_RIGHT] = int(right_p)
        
        c4d.EventAdd()
    

    On a side topic, please use [ code] [ /code] to insert code in your post, it increases the readability of them.

    If you have any question, please let me know.
    Cheers,
    Maxime



  • On 11/07/2018 at 01:05, xxxxxxxx wrote:

    Thanks Maxime,

    i got there in the end, my solution was far less elegant than yours though, so thank you for spending the time to look through my code, i can certainly learn lots from your approach.

    Apologies also for my scrappy code - there was parts in there that made no sense whatsoever so kudos for managing to read through that.

    I'll post my solution below for reference but anyone who references this thread should definitely go with Maximes above suggestion.

    def screenCalc(guide, cZ, bd, sf, rd_w, rd_h) :  
            
            
      gPos = guide.GetMg().off  # get global position of guide  
      convertPos = bd.WS(gPos)  # convert world to screen space  
      
            
      # Perform safe zone maths  
      convertPos[0] = (convertPos[0] - sf["cl"])/(sf["cr"]-sf["cl"])  
      convertPos[1] = (convertPos[1] - sf["ct"])/(sf["cb"]-sf["ct"])  
      convertPos[2] = (cZ - convertPos[2])/cZ    
            
      gV1 = convertPos[0]  # get x from vector  
      gV2 = convertPos[1]  # get y from vector  
      
            
      # Remaps vector values to screenspace values, aswell as inverts  
      g_Xpos = c4d.utils.RangeMap(gV1, 0, 1, 0, rd_w, True)  
      INVg_Xpos = c4d.utils.RangeMap(gV1, 1, 0, 0, rd_w, True)  
        
      g_Ypos = c4d.utils.RangeMap(gV2, 0, 1, 0, rd_h, True)  
      INVg_Ypos = c4d.utils.RangeMap(gV2, 1, 0, 0, rd_h, True)  
        
      # Loads final values into a list and returns it  
      pos = [int(g_Xpos), int(INVg_Xpos), int(g_Ypos), int(INVg_Ypos)]  
            
      return pos  
      
      
    def main() :  
        
      # +------- GET DOCUMENT DATA --------#  
        
      bd = doc.GetActiveBaseDraw()                 # Get current view  
      rd = doc.GetActiveRenderData()               # Get Render Setting  
      rd_w = rd[c4d.RDATA_XRES_VIRTUAL]            # Get X resolution  
      rd_h = rd[c4d.RDATA_YRES_VIRTUAL]            # Get Y resolution  
      sf = bd.GetSafeFrame()                       # Get SafeFrame dims  
        
      # +------- GET CUSTOM DATA --------#  
      obj = op.GetObject()                         # Get Null  
      cam = obj[c4d.ID_USERDATA,2]                 # Get Camera  
      top = obj[c4d.ID_USERDATA,3]                 # GetGuideObjects  
      bottom = obj[c4d.ID_USERDATA,7]              # --------------  
      left = obj[c4d.ID_USERDATA,8]                # --------------  
      right = obj[c4d.ID_USERDATA,9]               # --------------  
      switch = obj[c4d.ID_USERDATA,4]              # Get Switch  
      cZ = cam[c4d.CAMERAOBJECT_TARGETDISTANCE]    # Get z-distance  
      
      # If tag is activated  
        
      if switch:  
            
          # Use function to grab data  
          try:     
              topPos = screenCalc(top, cZ, bd, sf, rd_w, rd_h)  
              bottomPos = screenCalc(bottom, cZ, bd, sf, rd_w, rd_h)  
              leftPos = screenCalc(left, cZ, bd, sf, rd_w, rd_h)  
              rightPos = screenCalc(right, cZ, bd, sf, rd_w, rd_h)  
                
              # SET RENDER DATA  
              rd[c4d.RDATA_RENDERREGION_TOP] = topPos[2]  
              rd[c4d.RDATA_RENDERREGION_BOTTOM] = bottomPos[3]  
              rd[c4d.RDATA_RENDERREGION_LEFT] = leftPos[0]  
              rd[c4d.RDATA_RENDERREGION_RIGHT] = rightPos[1]  
      
              doc.SetActiveRenderData(rd)  
              c4d.EventAdd()  
            
          except ZeroDivisionError:  
              pass  
      else:  
          pass  
    
    

    Thanks again,

    Cerac


Log in to reply