source: 3DVCSoftware/branches/HTM-13.1-dev0/source/Lib/TAppCommon/TAppComCamPara.cpp @ 1314

Last change on this file since 1314 was 1175, checked in by tech, 10 years ago

Added direct dependency type for qtl.
Updated cfg files.
updated copy right headers.

File size: 54.9 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2015, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34
35
36
37// Include files
38#include "TAppComCamPara.h"
39
40
41#include <stdlib.h>
42#include <math.h>
43#include <errno.h>
44#include <assert.h>
45#include <vector>
46#include <iostream>
47#include <fstream>
48#include <algorithm>
49#include <functional>
50#include <string>
51#if H_3D
52
53
54Void
55TAppComCamPara::xCreateLUTs( UInt uiNumberSourceViews, UInt uiNumberTargetViews, Double****& radLUT, Int****& raiLUT, Double***& radShiftParams, Int64***& raiShiftParams )
56{
57  AOF( m_uiBitDepthForLUT == 8 );
58  AOF( radShiftParams == NULL && raiShiftParams == NULL && radLUT == NULL && raiLUT == NULL );
59
60  uiNumberSourceViews = std::max( (UInt) 1, uiNumberSourceViews );
61  uiNumberTargetViews = std::max( (UInt) 1, uiNumberTargetViews );
62
63  radShiftParams = new Double** [ uiNumberSourceViews ];
64  raiShiftParams = new Int64 ** [ uiNumberSourceViews ];
65  radLUT         = new Double***[ uiNumberSourceViews ];
66  raiLUT         = new Int   ***[ uiNumberSourceViews ];
67
68  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
69  {
70    radShiftParams[ uiSourceView ] = new Double* [ uiNumberTargetViews ];
71    raiShiftParams[ uiSourceView ] = new Int64 * [ uiNumberTargetViews ];
72    radLUT        [ uiSourceView ] = new Double**[ uiNumberTargetViews ];
73    raiLUT        [ uiSourceView ] = new Int   **[ uiNumberTargetViews ];
74
75    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
76    {
77      radShiftParams[ uiSourceView ][ uiTargetView ]      = new Double [ 2 ];
78      raiShiftParams[ uiSourceView ][ uiTargetView ]      = new Int64  [ 2 ];
79
80      radLUT        [ uiSourceView ][ uiTargetView ]      = new Double*[ 2 ];
81      radLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Double [ 257 ];
82      radLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Double [ 257 ];
83
84      raiLUT        [ uiSourceView ][ uiTargetView ]      = new Int*   [ 2 ];
85      raiLUT        [ uiSourceView ][ uiTargetView ][ 0 ] = new Int    [ 257 ];
86      raiLUT        [ uiSourceView ][ uiTargetView ][ 1 ] = new Int    [ 257 ];
87    }
88  }
89}
90
91Void
92TAppComCamPara::xCreate2dArray( UInt uiNum1Ids, UInt uiNum2Ids, Int**& raaiArray )
93{
94  AOT( raaiArray || uiNum1Ids == 0 || uiNum2Ids == 0 );
95  raaiArray = new Int* [ uiNum1Ids ];
96  for( UInt uiId1 = 0; uiId1 < uiNum1Ids; uiId1++ )
97  {
98    raaiArray[ uiId1 ] = new Int [ uiNum2Ids ];
99  }
100}
101
102
103Void
104TAppComCamPara::xInit2dArray( UInt uiNum1Ids, UInt uiNum2Ids, Int**& raaiArray, Int iValue )
105{
106  for( UInt uiId1 = 0; uiId1 < uiNum1Ids; uiId1++ )
107  {
108    for( UInt uiId2 = 0; uiId2 < uiNum2Ids; uiId2++ )
109    {
110      raaiArray[ uiId1 ][ uiId2 ] = iValue;
111    }
112  }
113}
114
115
116Void
117TAppComCamPara::convertNumberString( Char* pchViewNumberString, std::vector<Int>& raiViewNumbers, Double dViewNumPrec )
118{
119  Bool bStringIsRange = false;
120  Int  iIdx           = 0;
121  std::vector<Double> adViewNumbers;
122
123  while( pchViewNumberString != 0 && pchViewNumberString[ iIdx ] != 0 )
124  {
125    if( pchViewNumberString[ iIdx ] == ':' )
126    {
127      bStringIsRange              = true;
128      pchViewNumberString[ iIdx ] = ' ';
129    }
130    iIdx++;
131  }
132
133  Char* pcNextStart = pchViewNumberString;
134  Char* pcEnd       = pcNextStart + iIdx;
135  Char* pcOldStart  = 0;
136
137  while( pcNextStart < pcEnd )
138  {
139    errno = 0;
140    adViewNumbers.push_back( ( strtod( pcNextStart, &pcNextStart ) ) );
141
142    if( errno == ERANGE || pcNextStart == pcOldStart )
143    {
144      std::cerr << "Error Parsing View Number String: `" << pchViewNumberString << "'" << std::endl;
145      AOT(true);
146      exit( EXIT_FAILURE );
147    };
148
149    while( pcNextStart < pcEnd && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++;
150
151    pcOldStart = pcNextStart;
152  }
153
154  if( bStringIsRange )
155  {
156    if( adViewNumbers.size() != 3 )
157    {
158      std::cerr << "Error Parsing SynthViewNumbers: `" << pchViewNumberString << "'" << std::endl;
159      AOT(true);
160      exit( EXIT_FAILURE );
161    }
162
163    Double dRangeBegin = adViewNumbers[0];
164    Double dRangeStep  = adViewNumbers[1];
165    Double dRangeEnd   = adViewNumbers[2];
166
167    if( ( ( dRangeEnd - dRangeBegin > 0 ) != ( dRangeStep > 0 ) ) || dRangeStep == 0 )
168    {
169      std::cerr << "Error Parsing SynthViewNumbers: `" << pchViewNumberString << "'" << std::endl;
170      AOT(true);
171      exit( EXIT_FAILURE );
172    }
173
174    raiViewNumbers.clear();
175
176    Double dFac = ( dRangeBegin > dRangeEnd ? -1 : 1 );
177
178    for( Double dViewNumber = dRangeBegin; ( dViewNumber - dRangeEnd ) * dFac <= 0; dViewNumber += dRangeStep )
179    {
180      raiViewNumbers.push_back( (Int)( dViewNumber * dViewNumPrec ) );
181    }
182  }
183  else
184  {
185    for( UInt uiViewNum = 0; uiViewNum < adViewNumbers.size(); uiViewNum++ )
186    {
187      raiViewNumbers.push_back( (Int)( adViewNumbers[ uiViewNum ] * dViewNumPrec ) );
188    }
189  }
190}
191
192
193Void
194TAppComCamPara::xReadCameraParameterFile( Char* pchCfgFileName )
195{
196  std::ifstream cCfgStream( pchCfgFileName, std::ifstream::in );
197  if( !cCfgStream )
198  {
199    std::cerr << "Failed to open camera parameter file: `" << pchCfgFileName << "'" << std::endl;
200    exit( EXIT_FAILURE );
201  }
202
203  Int iLineNumber = 0;
204  do
205  {
206    std::string cLine;
207    getline( cCfgStream, cLine );
208    iLineNumber++;
209
210    size_t iStart = cLine.find_first_not_of( " \t\n\r" );
211
212    if( iStart == std::string::npos )
213    {
214      continue;
215    }
216
217    if( cLine[iStart] == '#' )
218    {
219      continue;
220    }
221
222    Char* pcNextStart = (Char*) cLine.data();
223    Char* pcEnd = pcNextStart + cLine.length();
224
225    std::vector<Double> caNewLine;
226    caNewLine.clear();
227
228    Char* pcOldStart = 0;
229    while( pcNextStart < pcEnd )
230    {
231      errno = 0;
232      caNewLine.push_back( strtod( pcNextStart, &pcNextStart ) ) ;
233
234      if( errno == ERANGE || ( pcNextStart == pcOldStart ) )
235      {
236        std::cerr << "Failed reading config file: `" << pchCfgFileName << "' Error parsing double values in Line: " << iLineNumber << ' ' << std::endl;
237        assert( 0 );
238        exit( EXIT_FAILURE );
239      };
240      pcOldStart = pcNextStart;
241
242      while( ( pcNextStart < pcEnd ) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++;
243    }
244
245    if ( ( caNewLine.size() != 2 ) && ( caNewLine.size() != 7 ) && ( caNewLine.size() != 6 ) && ( caNewLine.size() != 8 ) )
246    {
247      std::cerr << "Failed reading config file: `" << pchCfgFileName << "'" << std::endl;
248      std::cerr << "Invalid number of entries" << std::endl;
249      AOF(false);
250      exit( EXIT_FAILURE );
251    }
252    m_aadCameraParameters.push_back( caNewLine );
253  }
254  while( cCfgStream );
255}
256
257Void
258TAppComCamPara::xGetCodedCameraData( UInt uiSourceView, UInt uiTargetView, Bool bByIdx,  UInt uiFrame, Int& riScale, Int& riOffset, Int& riPrecision )
259{
260  if( bByIdx )
261  {
262    uiSourceView = m_aiBaseViews[ uiSourceView ];
263    uiTargetView = m_aiBaseViews[ uiTargetView ];
264  }
265
266  Int iFoundLine = -1;
267  for( UInt uiCurViewLine = 0; uiCurViewLine < m_aadCameraParameters.size(); uiCurViewLine++ )
268  {
269    if ( m_aadCameraParameters[uiCurViewLine].size() == 2 )
270      continue;
271
272    if(      ( (Int)( m_aadCameraParameters[ uiCurViewLine ][ 3 ] * m_dViewNumPrec ) == uiSourceView )
273          && ( (Int)( m_aadCameraParameters[ uiCurViewLine ][ 2 ] * m_dViewNumPrec ) == uiTargetView )
274      )
275    {
276      if( ( (UInt)m_aadCameraParameters[ uiCurViewLine ][ 0 ] <= uiFrame ) && ( (UInt)m_aadCameraParameters[ uiCurViewLine ][ 1 ] >= uiFrame ) )
277      {
278        if( iFoundLine != -1 )
279        {
280          std::cerr << "Error CameraParameters for SourceView " << (Double) uiSourceView / m_dViewNumPrec << " and Target View " << (Double) uiTargetView / m_dViewNumPrec << " and Frame " << uiFrame << " given multiple times."  << std::endl;
281          AOT(true);
282          exit( EXIT_FAILURE );
283        }
284        else
285        {
286          iFoundLine = uiCurViewLine;
287        }
288      }
289    }
290  }
291
292  if ( iFoundLine == -1 )
293  {
294    std::cerr << "Error CameraParameters for SourceView " << (Double) uiSourceView / m_dViewNumPrec << " and Target View " << (Double) uiTargetView / m_dViewNumPrec << " and Frame " << uiFrame << " not found."  << std::endl;
295    AOT(true);
296    exit( EXIT_FAILURE );
297  }
298
299  riScale     = (Int)( m_aadCameraParameters[ iFoundLine ][ 4 ] );
300  riOffset    = (Int)( m_aadCameraParameters[ iFoundLine ][ 5 ] );
301  riPrecision = (Int)( m_aadCameraParameters[ iFoundLine ][ 6 ] );
302}
303
304Bool
305TAppComCamPara::xGetCameraDataRow( Int iView, UInt uiFrame, UInt& ruiFoundLine )
306{
307  ruiFoundLine = -1;
308  for( UInt uiCurViewLine = 0; uiCurViewLine < m_aadCameraParameters.size(); uiCurViewLine++ )
309  {
310    if( (Int)( m_aadCameraParameters[ uiCurViewLine ][ 0 ] * m_dViewNumPrec ) == iView )
311    {
312      if( ( (UInt)m_aadCameraParameters[ uiCurViewLine ][ 1 ] <= uiFrame ) && ( (UInt)m_aadCameraParameters[ uiCurViewLine ][ 2 ] >= uiFrame ) )
313      {
314        if( ruiFoundLine != -1 )
315        {
316          std::cerr << "Error CameraParameters for View " << (Double) iView / m_dViewNumPrec << " and Frame " << uiFrame << " given multiple times."  << std::endl;
317          exit( EXIT_FAILURE );
318        }
319        else
320        {
321          ruiFoundLine = uiCurViewLine;
322        }
323      }
324    }
325  }
326  return ( ruiFoundLine == -1 );
327}
328
329
330Void
331TAppComCamPara::xGetSortedViewList( const std::vector<Int>& raiViews, std::vector<Int>& raiSortedViews, std::vector<Int>& raiId2SortedId, std::vector<Int>& raiSortedId2Id )
332{
333  AOF( raiViews.size() > 0 );
334  Int iNumViews   = (Int)raiViews.size();
335  raiId2SortedId  = std::vector<Int>( raiViews.size(), -1 );
336  raiSortedId2Id.clear();
337  raiSortedViews.clear();
338  for( Int iSortId = 0; iSortId < iNumViews; iSortId++ )
339  {
340    Int  iLeftMostBaseId = -1;
341    for( Int iBaseId = 0; iLeftMostBaseId == -1 && iBaseId < iNumViews; iBaseId++ )
342    {
343      if( raiId2SortedId[ iBaseId ] == -1 )
344      {
345        UInt   uiFoundLine   = -1;
346        xGetCameraDataRow( raiViews[ iBaseId ], 0, uiFoundLine );
347        AOT(   uiFoundLine  == -1 ); // something wrong
348        Double dXPos         = m_aadCameraParameters[ uiFoundLine ][ 4 ];
349        Double dZNear        = m_aadCameraParameters[ uiFoundLine ][ 6 ];
350        Double dZFar         = m_aadCameraParameters[ uiFoundLine ][ 7 ];
351        Double dSign         = ( dZFar > 0 ? 1.0 : -1.0 );
352        Bool   bLeftMost     = true;
353        AOF( dZNear * dZFar  > 0.0 ); // otherwise, z parameters are not correct
354
355        for( Int iTestBaseId = 0; bLeftMost && iTestBaseId < iNumViews; iTestBaseId++ )
356        {
357          if( iTestBaseId != iBaseId && raiId2SortedId[ iTestBaseId ] == -1 )
358          {
359            UInt   uiFoundLineTest  = -1;
360            xGetCameraDataRow( raiViews[ iTestBaseId ], 0, uiFoundLineTest );
361            AOT(   uiFoundLineTest == -1 ); // something wrong
362            Double dXPosTest        = m_aadCameraParameters[ uiFoundLineTest ][ 4 ];
363            Double dZNearTest       = m_aadCameraParameters[ uiFoundLineTest ][ 6 ];
364            Double dZFarTest        = m_aadCameraParameters[ uiFoundLineTest ][ 7 ];
365            AOF( dZNearTest * dZFarTest > 0.0 ); // otherwise, z parameters are not correct
366            AOF( dZNearTest * dSign     > 0.0 ); // otherwise, z parameters are not consistent
367            Double dDeltaXPos       = dSign * ( dXPosTest - dXPos );
368            bLeftMost               = ( bLeftMost && dDeltaXPos > 0.0 );
369          }
370        }
371        if( bLeftMost )
372        {
373          iLeftMostBaseId = iBaseId;
374        }
375      }
376    }
377    AOT( iLeftMostBaseId == -1 ); // something wrong
378    raiId2SortedId[ iLeftMostBaseId ] = iSortId;
379    raiSortedId2Id.push_back( iLeftMostBaseId );
380    raiSortedViews.push_back( raiViews[ iLeftMostBaseId ] );
381  }
382
383  // sanity check
384  if( iNumViews > 2 )
385  {
386    Int   iDeltaView  = gSign( raiSortedViews[ 1 ] - raiSortedViews[ 0 ] );
387    Bool  bOutOfOrder = false;
388    for(  Int  iSIdx  = 2; iSIdx < iNumViews; iSIdx++ )
389    {
390      bOutOfOrder = ( bOutOfOrder || iDeltaView * gSign( raiSortedViews[ iSIdx ] - raiSortedViews[ iSIdx - 1 ] ) < 0 );
391    }
392    if( bOutOfOrder )
393    {
394      std::cerr << "ERROR: View numbering must be strictly increasing or decreasing from left to right" << std::endl;
395      exit(EXIT_FAILURE);
396    }
397  }
398}
399
400
401#if !HHI_CAM_PARA_K0052
402Void
403TAppComCamPara::xGetViewOrderIndices( const std::vector<Int>& raiId2SortedId, std::vector<Int>& raiVOIdx )
404{
405  AOF( raiId2SortedId.size() );
406  raiVOIdx  =      raiId2SortedId;
407  Int iSize = (Int)raiId2SortedId.size();
408  Int iOffs =      raiId2SortedId[ 0 ];
409  for( Int iIdx = 0; iIdx < iSize; iIdx++ )
410  {
411    raiVOIdx[ iIdx ] -= iOffs;
412  }
413}
414#endif
415
416
417Bool
418TAppComCamPara::xGetCamParsChangeFlag()
419{
420  Bool bChangeDetected = false;
421  for( Int iBaseViewId = 0; !bChangeDetected && iBaseViewId < m_iNumberOfBaseViews; iBaseViewId++ )
422  {
423    if ( m_bSetupFromCoded )
424    {
425      for( Int iTargetViewId = 0; !bChangeDetected && iTargetViewId < m_iNumberOfBaseViews; iTargetViewId++ )
426      {
427        Int iTargetView = m_aiBaseViews[iTargetViewId];
428        Int iSourceView = m_aiBaseViews[iBaseViewId  ];
429
430        Int iS1 ,iSX;
431        Int iO1 ,iOX;
432        Int iP1 ,iPX;
433
434        if ( iSourceView == iTargetView )
435          continue;
436
437        xGetCodedCameraData( iSourceView, iTargetView, false, 0, iS1, iO1, iP1 );
438        for( UInt uiFrameId = m_uiFirstFrameId + 1; !bChangeDetected && uiFrameId <= m_uiLastFrameId; uiFrameId++ )
439        {
440          xGetCodedCameraData( iSourceView, iTargetView, false, uiFrameId, iSX, iOX, iPX );
441
442          if( iS1 != iSX || iO1 != iOX || iP1 != iPX )
443          {
444            bChangeDetected = true;
445          }
446        }
447      }
448    }
449    else
450    {
451      Int     iBaseView  = m_aiBaseViews[ iBaseViewId ];
452      Double  dFL1, dFLX;
453      Double  dCP1, dCPX;
454      Double  dCS1, dCSX;
455      Double  dZN1, dZNX;
456      Double  dZF1, dZFX;
457      Bool    bInterpolated;
458      xGetGeometryData( iBaseView, m_uiFirstFrameId, dFL1, dCP1, dCS1, bInterpolated );  AOT( bInterpolated );
459      xGetZNearZFar   ( iBaseView, m_uiFirstFrameId, dZN1, dZF1 );
460
461      for( UInt uiFrameId = m_uiFirstFrameId + 1; !bChangeDetected && uiFrameId <= m_uiLastFrameId; uiFrameId++ )
462      {
463        xGetGeometryData( iBaseView, uiFrameId, dFLX, dCPX, dCSX, bInterpolated );  AOT( bInterpolated );
464        xGetZNearZFar   ( iBaseView, uiFrameId, dZNX, dZFX );
465
466        if( dFL1 != dFLX || dCP1 != dCPX || dCS1 != dCSX || dZN1 != dZNX || dZF1 != dZFX )
467        {
468          bChangeDetected = true;
469        }
470      }
471    }
472  }
473  return bChangeDetected;
474}
475
476Int
477TAppComCamPara::xGetViewId( std::vector<Int> aiViewList, Int iBaseView )
478{
479  Int  iViewId = -1;
480  for( Int iId = 0; iId < (Int)aiViewList.size(); iId++ )
481  {
482    if( aiViewList[ iId ] == iBaseView )
483    {
484      iViewId = iId;
485      break;
486    }
487  }
488  AOT(   iViewId == -1 );
489  return iViewId;
490}
491
492Int
493TAppComCamPara::xGetBaseViewId( Int iBaseView )
494{
495  return xGetViewId( m_aiBaseViews, iBaseView );
496}
497
498
499Bool
500TAppComCamPara::xGetLeftRightView( Int iView, std::vector<Int> aiSortedViews, Int& riLeftView, Int& riRightView, Int& riLeftSortedViewIdx, Int& riRightSortedViewIdx )
501{
502  Bool bFoundLRView  = false;
503  Int  iLeftView     = -1;
504  Int  iRightView    = -1;
505  Int  iLeftViewIdx  = -1;
506  Int  iRightViewIdx = -1;
507  Bool bDecencdingVN = ( aiSortedViews.size() >= 2 && aiSortedViews[ 0 ] > aiSortedViews[ 1 ] );
508  Int  iFactor       = ( bDecencdingVN ? -1 : 1 );
509
510  for( Int iIdx = -1; iIdx < (Int)aiSortedViews.size(); iIdx++ )
511  {
512    if( iIdx == -1 )
513    {
514      if( ( aiSortedViews[ iIdx + 1 ] - iView ) * iFactor > 0  )
515      {
516        bFoundLRView  = false;
517        iLeftView     = -1;
518        iRightView    = aiSortedViews[ iIdx + 1 ];
519        iLeftViewIdx  = -1;
520        iRightViewIdx = iIdx + 1;
521        break;
522      }
523    }
524    else if ( iIdx == (Int)aiSortedViews.size() - 1 )
525    {
526      if( ( aiSortedViews[ iIdx ] - iView ) * iFactor < 0  )
527      {
528        bFoundLRView  = false;
529        iLeftView     = aiSortedViews[ iIdx ];
530        iRightView    = -1;
531        iLeftViewIdx  = iIdx;
532        iRightViewIdx = -1;
533        break;
534      }
535    }
536    else
537    {
538      if( ( ( aiSortedViews[ iIdx ] - iView ) * iFactor <= 0 ) && ( ( aiSortedViews[ iIdx + 1 ] - iView ) * iFactor >= 0 ) )
539      {
540        bFoundLRView  = true;
541        iLeftView     = aiSortedViews[ iIdx ];
542        iRightView    = aiSortedViews[ iIdx + 1 ];
543        iLeftViewIdx  = iIdx;
544        iRightViewIdx = iIdx + 1;
545        break;
546      }
547    }
548  }
549
550  if ( ( iView == iLeftView ) || ( iView == iRightView ) )
551  {
552    iLeftViewIdx  = ( iView == iLeftView ) ? iLeftViewIdx : iRightViewIdx;
553    iRightViewIdx = iLeftViewIdx;
554    iLeftView     = iView;
555    iRightView    = iView;
556    bFoundLRView  = false;
557  }
558
559  riLeftView           = iLeftView;
560  riRightView          = iRightView;
561  riLeftSortedViewIdx  = iLeftViewIdx;
562  riRightSortedViewIdx = iRightViewIdx;
563
564  return bFoundLRView;
565}
566
567
568Void
569TAppComCamPara::xGetPrevAndNextBaseView( Int iSourceViewNum, Int iTargetViewNum, Int& riPrevBaseViewNum, Int& riNextBaseViewNum )
570{
571  Int iLeftView;
572  Int iRightView;
573  Int iDummy;
574  xGetLeftRightView( iTargetViewNum, m_aiSortedBaseViews, iLeftView, iRightView, iDummy, iDummy );
575
576  if( iLeftView == iRightView )
577  {
578    riPrevBaseViewNum = iLeftView;
579    riNextBaseViewNum = iLeftView;
580  }
581  else
582  {
583    Bool bDecencdingVN   = ( m_aiSortedBaseViews.size() >= 2 && m_aiSortedBaseViews[ 0 ] > m_aiSortedBaseViews[ 1 ] );
584    Bool bNextViewIsLeft = ( bDecencdingVN ? ( iSourceViewNum < iTargetViewNum ) : ( iSourceViewNum > iTargetViewNum ) );
585    if ( bNextViewIsLeft )
586    {
587      riPrevBaseViewNum = iRightView;
588      riNextBaseViewNum = iLeftView;
589    }
590    else
591    {
592      riPrevBaseViewNum = iLeftView;
593      riNextBaseViewNum = iRightView;
594    }
595  }
596}
597
598
599Void
600TAppComCamPara::xGetZNearZFar( Int iView, UInt uiFrame, Double& rdZNear, Double& rdZFar )
601{
602  UInt uiFoundLine = -1;
603  if( !xGetCameraDataRow( iView, uiFrame, uiFoundLine ) || !( m_aadCameraParameters[ uiFoundLine ].size() < 8 ) )
604  {
605    rdZNear = m_aadCameraParameters[ uiFoundLine ][ 6 ];
606    rdZFar  = m_aadCameraParameters[ uiFoundLine ][ 7 ];
607  }
608  else
609  {
610    std::cerr << "No ZNear or no ZFar for View " << (Double)iView / m_dViewNumPrec << " and Frame " << uiFrame << " given in CameraParameterFile" << std::endl;
611    exit( EXIT_FAILURE );
612  }
613}
614
615Void
616TAppComCamPara::xGetGeometryData( Int iView, UInt uiFrame, Double& rdFocalLength, Double& rdPosition, Double& rdCameraShift, Bool& rbInterpolated )
617{
618  UInt uiFoundLine = -1;
619  if ( !xGetCameraDataRow( iView, uiFrame, uiFoundLine ) && xIsIn( m_aiSortedBaseViews, iView ))
620  {
621    AOT( m_aadCameraParameters[ uiFoundLine ].size() < 6 );
622    rbInterpolated = false;
623    rdFocalLength =  m_aadCameraParameters[ uiFoundLine ][ 3 ];
624    rdPosition    =  m_aadCameraParameters[ uiFoundLine ][ 4 ];
625    rdCameraShift =  m_aadCameraParameters[ uiFoundLine ][ 5 ];
626  }
627  else
628  {
629    UInt uiLeftViewLine;
630    UInt uiRightViewLine;
631    Int  iLeftView;
632    Int  iRightView;
633    Int  iDummy;
634
635    if( !xGetLeftRightView( iView, m_aiSortedBaseViews, iLeftView, iRightView, iDummy, iDummy ) ||
636         xGetCameraDataRow( iLeftView,  uiFrame, uiLeftViewLine  )                             ||
637         xGetCameraDataRow( iRightView, uiFrame, uiRightViewLine )
638      )
639    {
640      std::cerr << "No left or no right base view next to view " << (Double)iView / m_dViewNumPrec << " for Frame " << uiFrame << " given in CameraParameterFile" << std::endl;
641      AOT(true);
642      exit( EXIT_FAILURE );
643    }
644    AOT( m_aadCameraParameters[ uiLeftViewLine  ].size() < 6 );
645    AOT( m_aadCameraParameters[ uiRightViewLine ].size() < 6 );
646
647    // Linear Interpolation
648    Double dFactor = ( (Double)( iView - iLeftView ) ) / ( (Double)( iRightView - iLeftView ) );
649    rdFocalLength  = m_aadCameraParameters[ uiLeftViewLine ][ 3 ] + dFactor * ( m_aadCameraParameters[ uiRightViewLine ][ 3 ] - m_aadCameraParameters[ uiLeftViewLine ][ 3 ] );
650    rdPosition     = m_aadCameraParameters[ uiLeftViewLine ][ 4 ] + dFactor * ( m_aadCameraParameters[ uiRightViewLine ][ 4 ] - m_aadCameraParameters[ uiLeftViewLine ][ 4 ] );
651    rdCameraShift  = m_aadCameraParameters[ uiLeftViewLine ][ 5 ] + dFactor * ( m_aadCameraParameters[ uiRightViewLine ][ 5 ] - m_aadCameraParameters[ uiLeftViewLine ][ 5 ] );
652    rbInterpolated = true;
653  }
654}
655
656Bool
657TAppComCamPara::xGetShiftParameterReal( UInt uiSourceView, UInt uiTargetView, UInt uiFrame, Bool bExternal, Bool bByIdx, Double& rdScale, Double& rdOffset )
658{
659  AOT( m_bSetupFromCoded );
660
661  Bool   bInterpolatedSource;
662  Double dMinDepthSource;
663  Double dMaxDepthSource;
664  Double dFocalLengthSource;
665  Double dPositionSource;
666  Double dIntersectionSource;
667
668  Bool   bInterpolatedTarget;
669  Double dPositionTarget;
670  Double dIntersectionTarget;
671  Double dFocalLengthTarget;
672
673  Int    iTargetViewNum;
674  Int    iSourceViewNum;
675
676  if( bByIdx )
677  {
678    iSourceViewNum = m_aiBaseViews[ uiSourceView ];
679    iTargetViewNum = ( bExternal ? m_aiSynthViews[ uiTargetView ] : m_aiBaseViews[ uiTargetView ] );
680  }
681  else
682  {
683    iSourceViewNum = (Int) uiSourceView;
684    iTargetViewNum = (Int) uiTargetView;
685  }
686
687  xGetGeometryData( iSourceViewNum, uiFrame, dFocalLengthSource, dPositionSource, dIntersectionSource, bInterpolatedSource );
688  xGetZNearZFar   ( iSourceViewNum, uiFrame, dMinDepthSource,    dMaxDepthSource );
689  xGetGeometryData( iTargetViewNum, uiFrame, dFocalLengthTarget, dPositionTarget, dIntersectionTarget, bInterpolatedTarget );
690
691  Double dFactor = dFocalLengthSource * ( dPositionTarget - dPositionSource );
692  rdScale        = dFactor * ( 1.0 / dMinDepthSource - 1.0 / dMaxDepthSource ) / (Double)( ( 1 << m_uiInputBitDepth ) - 1 );
693  rdOffset       = dFactor / dMaxDepthSource - dIntersectionTarget + dIntersectionSource;
694
695  return ( bInterpolatedSource || bInterpolatedTarget );
696}
697
698
699Void
700TAppComCamPara::xGetShiftParameterCoded( UInt uiSourceView, UInt uiTargetView, UInt uiFrame, Bool bByIdx, Int& riScale, Int& riOffset )
701{
702  if ( m_bSetupFromCoded )
703  {
704    if ( uiSourceView == uiTargetView )
705    {
706      riScale  = 0;
707      riOffset = 0;
708      return;
709    }
710    Int iCamParsCodedPrecision;
711    xGetCodedCameraData( uiSourceView, uiTargetView,  bByIdx, uiFrame, riScale, riOffset, iCamParsCodedPrecision );
712
713    if ( m_bCamParsCodedPrecSet )
714    {
715      AOT( m_uiCamParsCodedPrecision != (UInt) iCamParsCodedPrecision );
716    }
717    else
718    {
719      m_uiCamParsCodedPrecision = (UInt) iCamParsCodedPrecision;
720      m_bCamParsCodedPrecSet    = true;
721    }
722  }
723  else
724  {
725    Double  dScale, dOffset;
726    Bool    bInterpolated = xGetShiftParameterReal( uiSourceView, uiTargetView, uiFrame, false, bByIdx, dScale, dOffset );
727    AOT(    bInterpolated ); // must be base view
728
729    Double  dMultOffset   = (Double)( 1 << ( m_uiCamParsCodedPrecision + 1 ) );
730    Double  dMultScale    = (Double)( 1 << ( m_uiCamParsCodedPrecision + 1 + m_uiInputBitDepth ) );
731    riOffset              = (Int)floor( dMultOffset * dOffset + .5 );
732    riScale               = (Int)floor( dMultScale  * dScale  + .5 );
733  }
734}
735
736
737Void
738TAppComCamPara::xGetShiftParameterInt( UInt uiSourceView, UInt uiTargetView, UInt uiFrame, Bool bExternal, Bool bByIdx, Int64& riScale, Int64& riOffset )
739{
740  Int    iTargetViewNum;
741  Int    iSourceViewNum;
742  Int    iPrevBaseViewNum;
743  Int    iNextBaseViewNum;
744  Int    iTargetViewRelNum;
745
746  if( bByIdx )
747  {
748
749    iSourceViewNum = m_aiBaseViews[ uiSourceView ];
750
751    if ( bExternal )
752    {
753      iTargetViewNum    = m_aiSynthViews      [ uiTargetView ];
754      iTargetViewRelNum = m_aiRelSynthViewsNum[ uiTargetView ];
755    }
756    else
757    {
758      iTargetViewNum    = m_aiBaseViews       [ uiTargetView ];
759      iTargetViewRelNum = m_aiBaseId2SortedId [ uiTargetView ] * ((Int) m_dViewNumPrec );
760    }
761  }
762  else
763  {
764    iSourceViewNum = (Int) uiSourceView;
765    iTargetViewNum = (Int) uiTargetView;
766
767    if ( bExternal )
768    {
769      iTargetViewRelNum = m_aiRelSynthViewsNum[ xGetViewId( m_aiSynthViews, (Int) uiTargetView )];
770    }
771    else
772    {
773      iTargetViewRelNum = m_aiBaseId2SortedId[ xGetBaseViewId( uiTargetView) ] * ((Int) m_dViewNumPrec );
774    }
775  }
776  xGetPrevAndNextBaseView( iSourceViewNum, iTargetViewNum, iPrevBaseViewNum, iNextBaseViewNum );
777  AOT( iPrevBaseViewNum == -1 ); // should not happen
778  AOT( iNextBaseViewNum == -1 ); // should not happen
779
780  Int iSrcId    = xGetBaseViewId( iSourceViewNum   );
781  Int iPrevId   = xGetBaseViewId( iPrevBaseViewNum );
782  Int iNextId   = xGetBaseViewId( iNextBaseViewNum );
783  AOF( m_aaiScaleAndOffsetSet[ iSrcId ][ iPrevId ] ); // coded scale and offset must be set
784  AOF( m_aaiScaleAndOffsetSet[ iSrcId ][ iNextId ] ); // coded scale and offset must be set
785
786  Int iNextBaseViewRelNum = m_aiBaseId2SortedId[ iNextId ] * ((Int) m_dViewNumPrec );
787  Int iPrevBaseViewRelNum = m_aiBaseId2SortedId[ iPrevId ] * ((Int) m_dViewNumPrec );
788
789  Int64 iPrevScale  = (Int64)m_aaiCodedScale [ iSrcId ][ iPrevId ];
790  Int64 iNextScale  = (Int64)m_aaiCodedScale [ iSrcId ][ iNextId ];
791  Int64 iPrevOffset = (Int64)m_aaiCodedOffset[ iSrcId ][ iPrevId ] << m_uiBitDepthForLUT;
792  Int64 iNextOffset = (Int64)m_aaiCodedOffset[ iSrcId ][ iNextId ] << m_uiBitDepthForLUT;
793
794  if( iPrevBaseViewNum == iNextBaseViewNum )
795  {
796    riScale   = iNextScale;
797    riOffset  = iNextOffset;
798  }
799  else
800  {
801    riScale   = Int64( iTargetViewRelNum    - iPrevBaseViewRelNum ) * iNextScale;
802    riScale  += Int64( iNextBaseViewRelNum  - iTargetViewRelNum   ) * iPrevScale;
803    riOffset  = Int64( iTargetViewRelNum   - iPrevBaseViewRelNum ) * iNextOffset;
804    riOffset += Int64( iNextBaseViewRelNum - iTargetViewRelNum   ) * iPrevOffset;
805    Int64 iD  = Int64( iNextBaseViewRelNum - iPrevBaseViewRelNum );
806    Int64 iSA = ( riScale  > 0 ? iD / 2 : -iD / 2 );
807    Int64 iOA = ( riOffset > 0 ? iD / 2 : -iD / 2 );
808    riScale   = ( riScale  + iSA  ) / iD;
809    riOffset  = ( riOffset + iOA  ) / iD;
810  }
811}
812
813
814Void
815TAppComCamPara::xSetCodedScaleOffset( UInt uiFrame )
816{
817  for( UInt uiSourceId = 0; uiSourceId < m_iNumberOfBaseViews; uiSourceId++ )
818  {
819    for( UInt uiTargetId = 0; uiTargetId < m_iNumberOfBaseViews; uiTargetId++ )
820    {
821      Int iScale, iOffset;
822      xGetShiftParameterCoded( uiSourceId, uiTargetId, uiFrame, true, iScale, iOffset );
823      m_aaiCodedScale        [ uiSourceId ][ uiTargetId ] = iScale;
824      m_aaiCodedOffset       [ uiSourceId ][ uiTargetId ] = iOffset;
825      m_aaiScaleAndOffsetSet [ uiSourceId ][ uiTargetId ] = 1;
826    }
827  }
828}
829
830
831Void
832TAppComCamPara::xSetShiftParametersAndLUT( UInt uiNumberSourceViews, UInt uiNumberTargetViews, UInt uiFrame, Bool bExternalReference , Double****& radLUT, Int****& raiLUT, Double***& radShiftParams, Int64***& raiShiftParams )
833{
834  if( uiNumberSourceViews <= 1 || uiNumberTargetViews == 0 )
835  {
836    return;
837  }
838  AOF( radShiftParams != NULL && raiShiftParams != NULL && radLUT != NULL && raiLUT != NULL );
839  AOF( m_uiBitDepthForLUT == 8 );
840
841  Int     iLog2DivLuma   = m_uiBitDepthForLUT + m_uiCamParsCodedPrecision + 1 - m_iLog2Precision;   AOF( iLog2DivLuma > 0 );
842  Int     iLog2DivChroma = iLog2DivLuma + 1;
843
844  Double  dMaxDispDev    = 0.0;
845  Double  dMaxRndDispDvL = 0.0;
846  Double  dMaxRndDispDvC = 0.0;
847
848  for( UInt uiSourceView = 0; uiSourceView < uiNumberSourceViews; uiSourceView++ )
849  {
850    for( UInt uiTargetView = 0; uiTargetView < uiNumberTargetViews; uiTargetView++ )
851    {
852
853      // integer-valued scale and offset
854      Int64 iScale, iOffset;
855      xGetShiftParameterInt ( uiSourceView, uiTargetView, uiFrame, bExternalReference, true, iScale, iOffset );
856      raiShiftParams[ uiSourceView][ uiTargetView ][ 0 ] = iScale;
857      raiShiftParams[ uiSourceView][ uiTargetView ][ 1 ] = iOffset;
858
859      // offsets including rounding offsets
860      Int64 iOffsetLuma   = iOffset + ( ( 1 << iLog2DivLuma   ) >> 1 );
861      Int64 iOffsetChroma = iOffset + ( ( 1 << iLog2DivChroma ) >> 1 );
862
863      // real-valued scale and offset
864      Double dScale, dOffset;
865
866      if ( m_bSetupFromCoded )
867      {
868        dScale  = (Double) iScale  / (( Double ) ( 1 << iLog2DivLuma ));
869        dOffset = (Double) iOffset / (( Double ) ( 1 << iLog2DivLuma ));
870      }
871      else
872      {
873        xGetShiftParameterReal( uiSourceView, uiTargetView, uiFrame, bExternalReference, true, dScale, dOffset );
874      }
875
876      radShiftParams[ uiSourceView][ uiTargetView ][ 0 ] = dScale;
877      radShiftParams[ uiSourceView][ uiTargetView ][ 1 ] = dOffset;
878
879      for( UInt uiDepthValue = 0; uiDepthValue < 256; uiDepthValue++ )
880      {
881        // real-valued look-up tables
882        Double  dShiftLuma      = ( (Double)uiDepthValue * dScale + dOffset ) * Double( 1 << m_iLog2Precision );
883        Double  dShiftChroma    = dShiftLuma / 2;
884        radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = dShiftLuma;
885        radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = dShiftChroma;
886
887        // integer-valued look-up tables
888        Int64   iTempScale      = (Int64)uiDepthValue * iScale;
889        Int64   iTestScale      = ( iTempScale + iOffset       );   // for checking accuracy of camera parameters
890        Int64   iShiftLuma      = ( iTempScale + iOffsetLuma   ) >> iLog2DivLuma;
891        Int64   iShiftChroma    = ( iTempScale + iOffsetChroma ) >> iLog2DivChroma;
892        raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ uiDepthValue ] = (Int)iShiftLuma;
893        raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ uiDepthValue ] = (Int)iShiftChroma;
894
895        // maximum deviation
896#if H_3D_REN_MAX_DEV_OUT
897        m_dMaxShiftDeviation = std::max( m_dMaxShiftDeviation, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) / Double( 1 << m_iLog2Precision ) );       
898#endif
899        dMaxDispDev     = std::max( dMaxDispDev,    fabs( Double( (Int) iTestScale   ) - dShiftLuma * Double( 1 << iLog2DivLuma ) ) / Double( 1 << iLog2DivLuma ) );
900        dMaxRndDispDvL  = std::max( dMaxRndDispDvL, fabs( Double( (Int) iShiftLuma   ) - dShiftLuma   ) );
901        dMaxRndDispDvC  = std::max( dMaxRndDispDvC, fabs( Double( (Int) iShiftChroma ) - dShiftChroma ) );
902      }
903
904      radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
905      radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = radLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
906      raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 0 ][ 255 ];
907      raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 256 ] = raiLUT[ uiSourceView ][ uiTargetView ][ 1 ][ 255 ];
908    }
909  }
910
911  // check maximum deviation
912  Double  dMaxAllowedDispDev    =       Double( 1 << m_iLog2Precision ) / Double( 1 << m_uiCamParsCodedPrecision );       //  counting only the impact of camera parameter rounding
913  Double  dMaxAllowedRndDispDvL = 0.5 + Double( 1 << m_iLog2Precision ) / Double( 1 << m_uiCamParsCodedPrecision );       // final rounding and impact of camera parameter rounding
914  Double  dMaxAllowedRndDispDvC = 0.5 + Double( 1 << m_iLog2Precision ) / Double( 1 << m_uiCamParsCodedPrecision ) / 2.0; // final rounding and impact of camera parameter rounding
915
916  if( ( dMaxDispDev >= dMaxAllowedDispDev || dMaxRndDispDvL >= dMaxAllowedRndDispDvL || dMaxRndDispDvC >= dMaxAllowedRndDispDvC ) && !m_bSetupFromCoded )
917  {
918    std::cout << "Warning: Something wrong with the accuracy of coded camera parameters:" << std::endl;
919    if( dMaxDispDev    >= dMaxAllowedDispDev    )
920    {
921      std::cout << "   max disparity difference is " << dMaxDispDev    << " (allowed: " << dMaxAllowedDispDev    << ")" << std::endl;
922    }
923    if( dMaxRndDispDvL >= dMaxAllowedRndDispDvL )
924    {
925      std::cout << "   max rnd luma   disp diff is " << dMaxRndDispDvL << " (allowed: " << dMaxAllowedRndDispDvL << ")" << std::endl;
926    }
927    if( dMaxRndDispDvC >= dMaxAllowedRndDispDvC )
928    {
929      std::cout << "   max rnd chroma disp diff is " << dMaxRndDispDvC << " (allowed: " << dMaxAllowedRndDispDvC << ")" << std::endl;
930    }
931  }
932}
933
934Void
935TAppComCamPara::xSetShiftParametersAndLUT( UInt uiFrame )
936{
937  xInit2dArray             ( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiScaleAndOffsetSet, 0 );
938  xSetCodedScaleOffset     (                                                          uiFrame );
939  xSetShiftParametersAndLUT( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  uiFrame, false, m_adBaseViewShiftLUT,  m_aiBaseViewShiftLUT,  m_adBaseViewShiftParameter,  m_aiBaseViewShiftParameter  );
940  xSetShiftParametersAndLUT( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfSynthViews, uiFrame, true,  m_adSynthViewShiftLUT, m_aiSynthViewShiftLUT, m_adSynthViewShiftParameter, m_aiSynthViewShiftParameter );
941};
942
943
944Void
945TAppComCamPara::xGetCameraShifts( UInt uiSourceView, UInt uiTargetView, UInt uiFrame, Double& rdCamPosShift, Double& rdPicPosShift )
946{
947  Double  dDummy, dCamPosSource, dCamPosTarget, dPicPosSource, dPicPosTarget;
948  Bool    bInterpolatedSource, bInterpolatedTarget;
949  Int     iTargetViewNum = m_aiBaseViews[ uiTargetView ];
950  Int     iSourceViewNum = m_aiBaseViews[ uiSourceView ];
951
952  xGetGeometryData( iSourceViewNum, uiFrame, dDummy, dCamPosSource, dPicPosSource, bInterpolatedSource );
953  xGetGeometryData( iTargetViewNum, uiFrame, dDummy, dCamPosTarget, dPicPosTarget, bInterpolatedTarget );
954  AOT( bInterpolatedSource || bInterpolatedTarget );
955
956  rdCamPosShift =  ( dCamPosTarget - dCamPosSource );
957  rdPicPosShift = -( dPicPosTarget - dPicPosSource ); // to be consistent
958}
959
960
961
962#if !HHI_CAM_PARA_K0052
963Void
964TAppComCamPara::xSetPdmConversionParams()
965{
966  AOF( m_aiViewOrderIndex[ 0 ] == 0 );
967  if ( m_bSetupFromCoded || m_iNumberOfBaseViews    <  2 )
968  {
969    return;
970  }
971
972  //--- determine (virtual) camera parameter shift between view order index 1 and base view (view order index 0) ---
973  Double        dCamPosShift, dPicPosShift;
974  Int           iMinAbsVOI    = (1<<30);
975  Int           iMinAbsVOIId  = 0;
976  for( Int iBaseId = 1; iBaseId < m_iNumberOfBaseViews; iBaseId++ )
977  {
978    Int iAbsVOI = ( m_aiViewOrderIndex[ iBaseId ] < 0 ? -m_aiViewOrderIndex[ iBaseId ] : m_aiViewOrderIndex[ iBaseId ] );
979    if( iAbsVOI < iMinAbsVOI )
980    {
981      iMinAbsVOI   = iAbsVOI;
982      iMinAbsVOIId = iBaseId;
983    }
984  }
985  AOF( iMinAbsVOIId != 0 && iMinAbsVOI != 0 );
986  xGetCameraShifts( 0, iMinAbsVOIId, m_uiFirstFrameId, dCamPosShift, dPicPosShift );
987
988  //--- determine maximum absolute camera position shift, precision, and base scale ---
989  Double  dMaxAbsCamPosShift = 0.0;
990  for( Int iTargetId = 1; iTargetId < m_iNumberOfBaseViews; iTargetId++ )
991  {
992    for( Int iBaseId = 0; iBaseId < iTargetId; iBaseId++ )
993    {
994      xGetCameraShifts( (UInt)iBaseId, (UInt)iTargetId, m_uiFirstFrameId, dCamPosShift, dPicPosShift );
995      dCamPosShift        = ( dCamPosShift < 0.0                ? -dCamPosShift : dCamPosShift       );
996      dMaxAbsCamPosShift  = ( dCamPosShift > dMaxAbsCamPosShift ?  dCamPosShift : dMaxAbsCamPosShift );
997    }
998  }
999}
1000#endif
1001
1002
1003
1004TAppComCamPara::TAppComCamPara()
1005{
1006  m_dViewNumPrec              = VIEW_NUM_PREC;  // fixed
1007  m_iLog2Precision            = -1;
1008  m_uiInputBitDepth           = 0;
1009  m_uiBitDepthForLUT          = 8;              // fixed
1010  m_uiFirstFrameId            = 0;
1011  m_uiLastFrameId             = 0;
1012
1013  m_iNumberOfBaseViews        = -1;
1014  m_iNumberOfSynthViews       = -1;
1015
1016  m_uiCamParsCodedPrecision   = 0;
1017  m_bCamParsVaryOverTime      = true;
1018
1019  m_aaiCodedScale             = 0;
1020  m_aaiCodedOffset            = 0;
1021  m_aaiScaleAndOffsetSet      = 0;
1022
1023  m_adBaseViewShiftParameter  = 0;
1024  m_aiBaseViewShiftParameter  = 0;
1025  m_adSynthViewShiftParameter = 0;
1026  m_aiSynthViewShiftParameter = 0;
1027
1028  m_adBaseViewShiftLUT        = 0;
1029  m_aiBaseViewShiftLUT        = 0;
1030  m_adSynthViewShiftLUT       = 0;
1031  m_aiSynthViewShiftLUT       = 0;
1032
1033  m_bSetupFromCoded           = false;
1034  m_bCamParsCodedPrecSet      = false;
1035
1036#if H_3D_REN_MAX_DEV_OUT
1037  m_dMaxShiftDeviation        = -1; 
1038#endif
1039
1040}
1041
1042
1043TAppComCamPara::~TAppComCamPara()
1044{
1045  xDeleteArray( m_adBaseViewShiftParameter,  m_iNumberOfBaseViews, m_iNumberOfBaseViews     );
1046  xDeleteArray( m_aiBaseViewShiftParameter,  m_iNumberOfBaseViews, m_iNumberOfBaseViews     );
1047  xDeleteArray( m_adBaseViewShiftLUT,        m_iNumberOfBaseViews, m_iNumberOfBaseViews,  2 );
1048  xDeleteArray( m_aiBaseViewShiftLUT,        m_iNumberOfBaseViews, m_iNumberOfBaseViews,  2 );
1049
1050  xDeleteArray( m_adSynthViewShiftParameter, m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews));
1051  xDeleteArray( m_aiSynthViewShiftParameter, m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews));
1052  xDeleteArray( m_adSynthViewShiftLUT,       m_iNumberOfBaseViews, std::max((Int) 1 ,m_iNumberOfSynthViews), 2 );
1053  xDeleteArray( m_aiSynthViewShiftLUT,       m_iNumberOfBaseViews, std::max( (Int)1 ,m_iNumberOfSynthViews), 2 );
1054
1055  xDeleteArray( m_aaiCodedScale,             m_iNumberOfBaseViews );
1056  xDeleteArray( m_aaiCodedOffset,            m_iNumberOfBaseViews );
1057  xDeleteArray( m_aaiScaleAndOffsetSet,      m_iNumberOfBaseViews );
1058
1059}
1060
1061Void
1062TAppComCamPara::xSetupBaseViewsFromCoded()
1063{
1064  //===== get and sort views given in camera parameter file and set list of base views and related arrays =====
1065  // get left-right order and coding order from cfg-file
1066  std::vector<Int> aiViewOrderIdx;   // Left Right Order
1067  std::vector<Int> aiViewId ;        // Coding     Order
1068
1069  Int iMinViewOrderIdx = MAX_INT;
1070  for( UInt uiRow = 0; uiRow < m_aadCameraParameters.size(); uiRow++ )
1071  {
1072    if (m_aadCameraParameters[uiRow].size() != 2 )
1073      break;
1074
1075    Int iViewOrderIdx  = (Int)( m_aadCameraParameters[ uiRow ][ 1 ] );
1076    iMinViewOrderIdx   = std::min( iViewOrderIdx, iMinViewOrderIdx );
1077
1078    aiViewOrderIdx     .push_back( iViewOrderIdx );
1079    aiViewId           .push_back( (Int) m_aadCameraParameters[ uiRow ][ 0 ]  );
1080  }
1081
1082  // create base view numbers
1083  AOT( aiViewId.size() != aiViewOrderIdx.size() );
1084  m_iNumberOfBaseViews = (Int) aiViewId.size();
1085  for (Int iCurBaseView = 0; iCurBaseView < m_iNumberOfBaseViews; iCurBaseView++ )
1086  {
1087    aiViewOrderIdx[iCurBaseView] = ( aiViewOrderIdx[iCurBaseView] - iMinViewOrderIdx);
1088    m_aiBaseViews      .push_back(  aiViewOrderIdx[iCurBaseView] * ( (Int) m_dViewNumPrec) );
1089    m_aiBaseId2SortedId.push_back( iCurBaseView );
1090    m_aiBaseSortedId2Id.push_back( iCurBaseView );
1091  }
1092
1093  m_iNumberOfBaseViews = (Int) m_aiBaseViews.size();
1094
1095  std::vector<Int> aiSortedViewOrderIdx = aiViewOrderIdx;
1096
1097  // sort base views according to View Order Idx
1098  m_aiSortedBaseViews = m_aiBaseViews;
1099  for (Int iCurBaseView = 1; iCurBaseView < m_iNumberOfBaseViews; iCurBaseView++ )
1100  {
1101    Int iCurViewOrder = aiSortedViewOrderIdx[iCurBaseView];
1102    for (Int iCurSearchPos = iCurBaseView; iCurSearchPos >= 0; iCurSearchPos-- )
1103    {
1104      if ( iCurViewOrder < aiSortedViewOrderIdx[iCurSearchPos] )
1105      {
1106        Int iTempViewId = m_aiSortedBaseViews[iCurSearchPos];
1107        m_aiSortedBaseViews[iCurSearchPos] = m_aiSortedBaseViews[iCurBaseView];
1108        m_aiSortedBaseViews[iCurBaseView ] = iTempViewId;
1109
1110        Int iTempViewOrderIdx = aiSortedViewOrderIdx[iCurSearchPos];
1111        aiSortedViewOrderIdx[iCurSearchPos] = aiSortedViewOrderIdx[iCurBaseView];
1112        aiSortedViewOrderIdx[iCurBaseView ] = iTempViewOrderIdx;
1113
1114        Int iTempPos = m_aiBaseSortedId2Id[iCurSearchPos];
1115        m_aiBaseSortedId2Id[iCurSearchPos] = m_aiBaseSortedId2Id[iCurBaseView];
1116        m_aiBaseSortedId2Id[iCurBaseView] = iTempPos;
1117        iCurBaseView--;
1118      }
1119    }
1120  }
1121
1122  for (Int iCurBaseView = 0; iCurBaseView < m_iNumberOfBaseViews; iCurBaseView++ )
1123  {
1124    m_aiBaseId2SortedId[m_aiBaseSortedId2Id[iCurBaseView]] = iCurBaseView;
1125  }
1126
1127  m_aiViewsInCfgFile = m_aiSortedBaseViews;
1128
1129  // check
1130  if( m_aiViewsInCfgFile.size() < 2 )
1131  {
1132    std::cerr << "Failed reading camera parameter file" << std::endl;
1133    std::cerr << "At least two views must be given" << std::endl;
1134    AOT(true);
1135    exit( EXIT_FAILURE );
1136  }
1137
1138  // translate coding order to view order
1139  for( UInt uiRow = 0; uiRow < m_aadCameraParameters.size(); uiRow++ )
1140{
1141    if (m_aadCameraParameters[uiRow].size() == 2 )
1142      continue;
1143
1144    m_aadCameraParameters[ uiRow ][ 2 ] = (Double) aiViewOrderIdx[ xGetViewId( aiViewId, (Int) m_aadCameraParameters[ uiRow ][ 2 ] ) ];
1145    m_aadCameraParameters[ uiRow ][ 3 ] = (Double) aiViewOrderIdx[ xGetViewId( aiViewId, (Int) m_aadCameraParameters[ uiRow ][ 3 ] ) ];
1146  }
1147}
1148
1149Void TAppComCamPara::xSetupBaseViews( Char* pchBaseViewNumbers, UInt uiNumBaseViews )
1150  {
1151    // init list
1152    std::vector<Int> aiViewsInCfg;
1153    for( UInt uiRow = 0; uiRow < m_aadCameraParameters.size(); uiRow++ )
1154    {
1155      aiViewsInCfg.push_back( (Int)( m_aadCameraParameters[ uiRow ][ 0 ] * m_dViewNumPrec ) );
1156    }
1157    // remove duplicated items
1158    std::sort( aiViewsInCfg.begin(), aiViewsInCfg.end() );
1159    std::vector<Int>::iterator cIterNewEnd = std::unique( aiViewsInCfg.begin(), aiViewsInCfg.end() );
1160    aiViewsInCfg.erase( cIterNewEnd, aiViewsInCfg.end() );
1161    // sort (from left to right)
1162    std::vector<Int> aiDummyI2SI, aiDummySI2I;
1163    xGetSortedViewList( aiViewsInCfg, m_aiViewsInCfgFile, aiDummyI2SI, aiDummySI2I );
1164    // check
1165    if( m_aiViewsInCfgFile.size() < 2 )
1166    {
1167      std::cerr << "Failed reading config file" << std::endl;
1168      std::cerr << "At least two views must be given" << std::endl;
1169      exit( EXIT_FAILURE );
1170    }
1171
1172
1173
1174  //===== set list of base views and related arrays =====
1175  if( pchBaseViewNumbers == 0 )
1176  {
1177    std::cerr << "BaseViewCameraNumbers must be given" << std::endl;
1178    exit( EXIT_FAILURE );
1179  };
1180
1181  convertNumberString( pchBaseViewNumbers, m_aiBaseViews, m_dViewNumPrec  );
1182  while( (UInt)m_aiBaseViews.size() > uiNumBaseViews )
1183  {
1184    m_aiBaseViews.pop_back();
1185  }
1186  xGetSortedViewList( m_aiBaseViews, m_aiSortedBaseViews, m_aiBaseId2SortedId, m_aiBaseSortedId2Id );
1187  m_iNumberOfBaseViews = (Int)m_aiBaseViews.size();
1188}
1189
1190
1191Void
1192TAppComCamPara::init( UInt   uiNumBaseViews,
1193                      UInt   uiInputBitDepth,
1194                      UInt   uiCodedCamParsPrecision,
1195                      UInt   uiStartFrameId,
1196                      UInt   uiNumFrames,
1197                      Char*  pchCfgFileName,
1198                      Char*  pchBaseViewNumbers,
1199                      Char*  pchSynthViewNumbers,
1200                      std::vector<Int>* paiSynthViewNumbers,
1201                      Int    iLog2Precision )
1202{
1203  //===== set miscellaneous variables =====
1204  m_uiInputBitDepth         = uiInputBitDepth;
1205  m_uiFirstFrameId          = uiStartFrameId;
1206  m_uiLastFrameId           = uiStartFrameId + uiNumFrames - 1;
1207  m_uiCamParsCodedPrecision = uiCodedCamParsPrecision;
1208  m_iLog2Precision          = iLog2Precision;
1209
1210  xReadCameraParameterFile( pchCfgFileName );
1211
1212  m_bSetupFromCoded         = ( m_aadCameraParameters[ 0 ].size() == 2 );
1213
1214  if ( m_bSetupFromCoded )
1215  {
1216    std::cout << "Detected decoded camera parameter file. Overwriting base view settings from cfg file. " << std::endl;
1217    xSetupBaseViewsFromCoded();
1218  }
1219  else
1220  {
1221    xSetupBaseViews( pchBaseViewNumbers, uiNumBaseViews );
1222  }
1223
1224  //===== set list of external (virtual) views =====
1225  m_aiSynthViews.clear();
1226
1227  if( pchSynthViewNumbers != 0 || paiSynthViewNumbers != 0)
1228  {
1229    std::vector<Int> aiTmpSynthViews;
1230
1231    AOT( ( pchSynthViewNumbers != NULL ) && ( paiSynthViewNumbers != NULL ) );
1232
1233    if ( pchSynthViewNumbers != NULL )
1234    {
1235      convertNumberString( pchSynthViewNumbers, aiTmpSynthViews, m_dViewNumPrec );
1236    }
1237    else
1238    {
1239      aiTmpSynthViews = (*paiSynthViewNumbers);
1240    }
1241
1242    for( UInt uiSId = 0; uiSId < (UInt)aiTmpSynthViews.size(); uiSId++ )
1243    {
1244
1245      Int iViewNumPrec        = (Int) m_dViewNumPrec;
1246      Int iLeftBaseViewIdx    =   aiTmpSynthViews[ uiSId ]                        / iViewNumPrec;
1247      Int iRightBaseViewIdx   = ( aiTmpSynthViews[ uiSId ] + (iViewNumPrec - 1) ) / iViewNumPrec;
1248
1249      if ( iLeftBaseViewIdx < 0 || iRightBaseViewIdx >= m_iNumberOfBaseViews )
1250      {
1251        std::cerr << "SynthViewCameraNumbers must be greater and equal to 0 and smaller than number of base views" << std::endl;
1252        AOT(true);
1253        exit( EXIT_FAILURE );
1254      }
1255
1256      Int64  iLeftBaseViewRelNum = iLeftBaseViewIdx  * iViewNumPrec;
1257      Int64 iRightBaseViewRelNum = iRightBaseViewIdx * iViewNumPrec;
1258
1259      Int64 iDiffBaseViewRelNum  = iRightBaseViewRelNum - iLeftBaseViewRelNum;
1260
1261      Int64 iSynthViewRelNum     = aiTmpSynthViews[ uiSId ];
1262      Int64 iLeftBaseNum         = m_aiSortedBaseViews[ iLeftBaseViewIdx  ];
1263      Int64 iRightBaseNum        = m_aiSortedBaseViews[ iRightBaseViewIdx ];
1264      Int64 iDiffBaseNum         = iRightBaseNum - iLeftBaseNum;
1265      Int64 iSynthViewNum;
1266
1267      if ( iDiffBaseViewRelNum != 0)
1268      {
1269        AOT( (Int) iDiffBaseViewRelNum != iViewNumPrec );
1270        Int iFact = iDiffBaseNum > 0 ? 1 : -1;
1271        iSynthViewNum = iLeftBaseNum + ( iDiffBaseNum * ( iSynthViewRelNum - iLeftBaseViewRelNum ) + (iViewNumPrec >> 1) * iFact ) / ( iViewNumPrec );
1272      }
1273      else
1274      {
1275        iSynthViewNum = iLeftBaseNum;
1276      }
1277
1278      m_aiRelSynthViewsNum.push_back(  aiTmpSynthViews[ uiSId ] );
1279      m_aiSynthViews      .push_back(  (Int) iSynthViewNum  );
1280    }
1281  }
1282  m_iNumberOfSynthViews = (Int)m_aiSynthViews.size();
1283
1284
1285  //===== set derived parameters =====
1286#if !HHI_CAM_PARA_K0052
1287  xGetViewOrderIndices( m_aiBaseId2SortedId, m_aiViewOrderIndex );
1288#endif
1289  m_bCamParsVaryOverTime = xGetCamParsChangeFlag();
1290
1291
1292  //===== create arrays =====
1293  xCreateLUTs   ( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_adBaseViewShiftLUT,  m_aiBaseViewShiftLUT,  m_adBaseViewShiftParameter,  m_aiBaseViewShiftParameter  );
1294  xCreateLUTs   ( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfSynthViews, m_adSynthViewShiftLUT, m_aiSynthViewShiftLUT, m_adSynthViewShiftParameter, m_aiSynthViewShiftParameter );
1295  xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiCodedScale           );
1296  xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiCodedOffset          );
1297  xCreate2dArray( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiScaleAndOffsetSet    );
1298  xInit2dArray  ( (UInt)m_iNumberOfBaseViews, (UInt)m_iNumberOfBaseViews,  m_aaiScaleAndOffsetSet, 0 );
1299
1300  //===== init arrays for first frame =====
1301  xSetShiftParametersAndLUT( m_uiFirstFrameId );
1302}
1303
1304
1305Void
1306TAppComCamPara::check( Bool bCheckViewRange, Bool bCheckFrameRange )
1307{
1308  if( bCheckFrameRange )
1309  {
1310    Double dDummy;
1311
1312    for( UInt uiBaseView = 0; uiBaseView < m_aiBaseViews.size(); uiBaseView++ )
1313    {
1314      if ( m_bSetupFromCoded )
1315      {
1316        for( UInt uiTargetView = 0; uiTargetView < m_aiBaseViews.size(); uiTargetView++ )
1317        {
1318          if ( uiTargetView == uiBaseView )
1319            continue;
1320
1321          for( UInt uiFrame = m_uiFirstFrameId; uiFrame <= m_uiLastFrameId; uiFrame++ )
1322          {
1323            Int iDummy;
1324
1325            xGetCodedCameraData( uiBaseView, uiTargetView, true , uiFrame, iDummy, iDummy, iDummy );
1326          }
1327        }
1328      }
1329      else
1330      {
1331        for( UInt uiFrame = m_uiFirstFrameId; uiFrame <= m_uiLastFrameId; uiFrame++ )
1332        {
1333          Bool bInterpolatedCur;
1334          xGetGeometryData( m_aiBaseViews[ uiBaseView ], uiFrame, dDummy, dDummy, dDummy, bInterpolatedCur );
1335          xGetZNearZFar   ( m_aiBaseViews[ uiBaseView ], uiFrame, dDummy, dDummy );
1336
1337          if( bInterpolatedCur )
1338          {
1339            std::cerr << "Error: CameraParameters for BaseView " << (Double)m_aiBaseViews[ uiBaseView ] / m_dViewNumPrec << " and Frame " << uiFrame << " not defined. "  << std::endl;
1340            exit( EXIT_FAILURE );
1341          }
1342        }
1343      }
1344    }
1345
1346    Bool bIgnoreFirst = true;     
1347    for( UInt uiERView = 0; uiERView < m_aiSynthViews.size() && !m_bSetupFromCoded; uiERView++ )
1348    {
1349      if ( xIsIn(m_aiViewsInCfgFile, m_aiSynthViews[ uiERView ] ) )
1350      {
1351        if ( bIgnoreFirst )
1352        {
1353          std::cout << "Ignoring CameraParameterFile entries for virtual view(s): " ;
1354          //GT: Integer precision virtual view camera parameters are always interpolated from coded views camera parameters.
1355          bIgnoreFirst = false; 
1356        }
1357        std::cout << (Double)m_aiSynthViews[ uiERView ] / m_dViewNumPrec << " " ; 
1358      }
1359    }
1360    if ( !bIgnoreFirst )
1361    {
1362      std::cout << std::endl; 
1363    }
1364
1365    Bool bInterpolateFirst = true; 
1366    Bool bAnyInterpolated  = false; 
1367    for( UInt uiERView = 0; uiERView < m_aiSynthViews.size() && !m_bSetupFromCoded; uiERView++ )
1368    {
1369      Bool bInterpolated = false;
1370      for( UInt uiFrame = m_uiFirstFrameId; uiFrame <= m_uiLastFrameId; uiFrame++ )
1371      {
1372        Bool bInterpolatedCur;
1373        xGetGeometryData( m_aiSynthViews[ uiERView ], uiFrame, dDummy, dDummy, dDummy, bInterpolatedCur );
1374        bInterpolated |= bInterpolatedCur;
1375      }
1376     
1377      if( bInterpolated )
1378      {
1379        bAnyInterpolated = true; 
1380        if ( bInterpolateFirst ) 
1381        {
1382          std::cout << "Interpolating camera parameters      for virtual view(s): " ; 
1383            bInterpolateFirst = false; 
1384        }         
1385        std::cout << (Double)m_aiSynthViews[ uiERView ] / m_dViewNumPrec << " " ; 
1386      }
1387    }
1388    if ( bAnyInterpolated )
1389      std::cout << std::endl;
1390  }
1391
1392  if( bCheckViewRange )
1393  {
1394    Bool bAllExist = true;
1395    for( Int iSynthViewIdx = 0; iSynthViewIdx < m_iNumberOfSynthViews; iSynthViewIdx++ )
1396    {
1397      Bool bIsBaseView;
1398      Int  iDummy;
1399      Bool bExist = getLeftRightBaseView( iSynthViewIdx, iDummy, iDummy, iDummy, bIsBaseView );
1400      bAllExist  &= ( bExist || bIsBaseView );
1401    }
1402    if( !bAllExist )
1403    {
1404      std::cerr << "SynthViewNumbers must be within the range of BaseViewNumbers"  << std::endl;
1405      exit( EXIT_FAILURE );
1406    }
1407  }
1408}
1409
1410
1411Void
1412TAppComCamPara::update( UInt uiFrameId )
1413{
1414
1415  m_iCurrentFrameId = uiFrameId;
1416  m_bCamParsCodedPrecSet = false;
1417
1418  if ( m_bCamParsVaryOverTime )
1419  {
1420    xSetShiftParametersAndLUT( m_uiFirstFrameId + uiFrameId );
1421  }
1422}
1423
1424#if H_3D_VSO
1425Void
1426TAppComCamPara::setDispCoeff( UInt uiFrameId, Int iViewIdx )
1427{
1428  UInt uiFrame = m_uiFirstFrameId + uiFrameId;
1429  Int  iSourceViewNum = m_aiBaseViews[ iViewIdx ];
1430  Double dBaseLine = 0.0;
1431  Double dFL1, dCS1, dCP1, dZN1, dZF1; 
1432  Bool bInterpolated;
1433  double dPos[3];
1434
1435  if( m_iNumberOfBaseViews == 3 )
1436  {
1437    xGetGeometryData( m_aiBaseViews[0], uiFrame, dFL1, dPos[0], dCS1, bInterpolated );
1438    xGetGeometryData( m_aiBaseViews[1], uiFrame, dFL1, dPos[1], dCS1, bInterpolated );
1439    xGetGeometryData( m_aiBaseViews[2], uiFrame, dFL1, dPos[2], dCS1, bInterpolated );
1440
1441    xGetGeometryData( iSourceViewNum, uiFrame, dFL1, dCP1, dCS1, bInterpolated );
1442    xGetZNearZFar   ( iSourceViewNum, uiFrame, dZN1, dZF1 );
1443
1444    dBaseLine = ( std::max( dPos[0], std::max( dPos[1], dPos[2] ) ) - std::min( dPos[0], std::min( dPos[1], dPos[2] ) ) ) / 2.0;
1445  }
1446  else if( m_iNumberOfBaseViews == 2 )
1447  {
1448    xGetGeometryData( m_aiBaseViews[0], uiFrame, dFL1, dPos[0], dCS1, bInterpolated );
1449    xGetGeometryData( m_aiBaseViews[1], uiFrame, dFL1, dPos[1], dCS1, bInterpolated );
1450
1451    xGetGeometryData( iSourceViewNum, uiFrame, dFL1, dCP1, dCS1, bInterpolated );
1452    xGetZNearZFar   ( iSourceViewNum, uiFrame, dZN1, dZF1 );
1453
1454    dBaseLine = dPos[0] - dPos[1];
1455  }
1456
1457  m_dDispCoeff = fabs( dFL1 * ( dBaseLine / 2.0 ) / 255.0 * ( 1.0/dZN1 - 1.0/dZF1 ) );
1458}
1459#endif
1460
1461Bool
1462TAppComCamPara::getLeftRightBaseView( Int iSynthViewIdx, Int &riLeftViewIdx, Int &riRightViewIdx, Int &riRelDistToLeft, Bool& rbIsBaseView )
1463{
1464  Int    iLeftSortedViewIdx, iRightSortedViewIdx, iDummy;
1465  Bool   bExist  = xGetLeftRightView( m_aiSynthViews[ iSynthViewIdx ], m_aiSortedBaseViews, iDummy, iDummy, iLeftSortedViewIdx, iRightSortedViewIdx );
1466  rbIsBaseView   = ( iLeftSortedViewIdx == iRightSortedViewIdx && iLeftSortedViewIdx != -1 );
1467
1468  Int iLeftViewIdx  = ( iLeftSortedViewIdx  != -1 ? m_aiBaseSortedId2Id[ iLeftSortedViewIdx  ] : -1 );
1469  Int iRightViewIdx = ( iRightSortedViewIdx != -1 ? m_aiBaseSortedId2Id[ iRightSortedViewIdx ] : -1 );
1470
1471  if ( iLeftSortedViewIdx != -1 && iRightSortedViewIdx != -1 )
1472  {
1473    riRelDistToLeft = getRelDistLeft(  iSynthViewIdx, iLeftViewIdx, iRightViewIdx);
1474  }
1475  else
1476  {
1477    riRelDistToLeft = -1;
1478  }
1479
1480  riLeftViewIdx  = iLeftViewIdx;
1481  riRightViewIdx = iRightViewIdx;
1482
1483  return bExist;
1484}
1485
1486Bool
1487  TAppComCamPara::xIsIn( std::vector<Int>& rVec, Int iElem) 
1488{
1489  Bool bFound = false; 
1490  for (Int idx = 0; idx < rVec.size() && !bFound; idx++)
1491  {
1492    bFound = bFound || rVec[idx] == iElem; 
1493  }
1494  return bFound;
1495}
1496
1497Int TAppComCamPara::getRelDistLeft( Int iSynthViewIdx, Int iLeftViewIdx, Int iRightViewIdx )
1498{
1499  //GT: Get normalized distance
1500  Int iLeftViewDist  = abs ( m_aiBaseId2SortedId[ iLeftViewIdx  ] * ((Int) m_dViewNumPrec) - m_aiRelSynthViewsNum [ iSynthViewIdx ]);
1501  Int iRightViewDist = abs ( m_aiBaseId2SortedId[ iRightViewIdx ] * ((Int) m_dViewNumPrec) - m_aiRelSynthViewsNum [ iSynthViewIdx ]);
1502  Int64 iDistSum = iLeftViewDist + iRightViewDist;
1503  return (iDistSum == 0) ? (1 << (REN_VDWEIGHT_PREC -1) ) : (Int) (( (((Int64) iLeftViewDist ) << REN_VDWEIGHT_PREC ) + (iDistSum >> 1) )  / iDistSum );
1504}
1505
1506Int
1507TAppComCamPara::synthRelNum2Idx( Int iRelNum )
1508{
1509  return xGetViewId(m_aiRelSynthViewsNum, iRelNum );
1510}
1511#endif
Note: See TracBrowser for help on using the repository browser.