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 which 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 which 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 which of these have the highest/minimum x and y values.
             The difference between highest/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 which 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 think it is because of the 
         Trapez formed viewport. */
 
     
     }
 
     private Vector3 FindBoundCord (int i, GameObject _GameObject){
          /*This 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 which returns the coordinates 
          from the bounding box I had to create a switch/case which 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 :)