GameObject width in screen space

Okay I'll go ahead and answer my own post: I made an attempt as "Whydoidoit" suggested

1. Find the desired GameObject you wish to measure

2. Identify its boundries

3. Identify the eight coordinates w$$anonymous$$ch forms the boundries

4. Convert these eight coordinates into Screen space coordinates

5. Locate the max/min values

6. Find the distance between max/min and you will get Width/Height

The output of it works fine when the object is properly fitted inside the viewport, but as soon the object begins to wander out of screen, the width and height goes crazy. The exact reason for that I don't know, I presume it is because of the shape of the camera.

I posted the example code w$$anonymous$$ch I tried out, hope it might be useful for someone else.

     private void FindCenterOnScreen(){
         _TargetPosition = camera.WorldToScreenPoint(_Target.transform.position);
         _TargetPosition.y = Screen.height-_TargetPosition.y;
     }
     
     // Don't be fooled by the method name, it also calculates height.
     private float FindWidthInScreen(GameObject _TargetGameObject){
         Vector2 _ObjectScreenCord, _Xmin = new Vector2(Screen.width,0), _Xmax = Vector2.zero, _Ymin = new Vector2(Screen.height,0), _Ymax = Vector2.zero;
         float _Height, _Width;    
         
 
         for(int i = 0; i != 8; i++){
             //FindBoundCord() locates the eight coordinates that forms the boundries, followed by converting the coordinates to screen space.
             // The entire script starts in FindBoundCord
             _ObjectScreenCord = camera.WorldToScreenPoint(FindBoundCord(i, _TargetGameObject));
             
             /* After gathering the coordinates and converting them to screen space
              we try to locate w$$anonymous$$ch of these have the $$anonymous$$ghest/minimum x and y values.
             The difference between $$anonymous$$ghest/minimum x and y must correspond to
              width and height.*/
             
                 if(_ObjectScreenCord.x > _Xmax.x){
                     _Xmax.x = _ObjectScreenCord.x;
                 }
                  else if(_ObjectScreenCord.x < _Xmin.x){
                     _Xmin.x = _ObjectScreenCord.x;
                 }    
                 if(_ObjectScreenCord.y > _Ymax.x){
                     _Ymax.x = _ObjectScreenCord.y;
                 }
                 else if(_ObjectScreenCord.y < _Ymin.x){
                     _Ymin.x = _ObjectScreenCord.y;
                 }            
         }
         
         
         
         //Too measure the distance between them, I use the Vector2 method Distance.
         _Height = Vector2.Distance(_Ymax, _Ymin);
         if (_Height > Screen.height || _Height < 0){
             _Height = 0;
         }
         
         _Width = Vector2.Distance(_Xmax, _Xmin);
         if (_Width > Screen.width || _Width < 0){
             _Width = 0;
         }
         
         // Here we simply make a check on w$$anonymous$$ch of the height or the 
         // width is the biggest. It was a necessary part for my project.
         if (_Height > _Width ){
             return _Height;
         } else {
             return _Width;
         }
         /*
         The method appears to work, though there are som serious issues when 
         Screen coordinates gets into negative values.
         When screencoordinates get negative the width/height 
         explodes, and I t$$anonymous$$nk it is because of the 
         Trapez formed viewport. */
 
     
     }
 
     private Vector3 FindBoundCord (int i, GameObject _GameObject){
          /*T$$anonymous$$s is basically where the code starts. It starts out by creating a 
           * bounding box around the target GameObject. 
          It calculates the 8 coordinates forming the bounding box, and 
          returns them all to the for loop.
          Because there are no real method w$$anonymous$$ch returns the coordinates 
          from the bounding box I had to create a switch/case w$$anonymous$$ch utillized 
          Bounds.center and Bounds.extents.*/
 
         Bounds _TargetBounds = _GameObject.renderer.bounds;
         Vector3 _TargetCenter = _TargetBounds.center;
         Vector3 _TargetExtents = _TargetBounds.extents;
 
         
         switch(i){
         case 0:
             return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y, _TargetExtents.z); 
         case 1:
             return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y, _TargetExtents.z*-1);
         case 2:
             return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y*-1, _TargetExtents.z);
         case 3:
             return _TargetCenter + new Vector3(_TargetExtents.x, _TargetExtents.y*-1, _TargetExtents.z*-1);
         case 4:
             return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y, _TargetExtents.z);
         case 5:
             return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y, _TargetExtents.z*-1);
         case 6:
             return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y*-1, _TargetExtents.z);
         case 7:
             return _TargetCenter + new Vector3(_TargetExtents.x*-1, _TargetExtents.y*-1, _TargetExtents.z*-1);
         default:
             return Vector3.zero;
         }
 
     }

Sorry for the horrible formatting, not used to post such long code snippits :)