def main():
    ##  Initial print
    print('\n')
    print('########################################################')
    print('#############   EQUALLY SLOPED TOMOGRAPHY  #############')
    print('########################################################')
    print('\n')


    ##  Get the startimg time of the reconstruction
    time1 = time.time()



    ##  Get input arguments
    args = getArgs()


    
    ##  Get input directory
    pathin = args.pathin
    
    if pathin[len(pathin)-1] != '/':
        pathin += '/'

    if os.path.exists( pathin ) is False:
        sys.exit('\nERROR: input directory ', pathin,' does not exist!')

    print('\nInput directory:\n', pathin)



    ##  Get input sinogram
    sinofile = pathin + args.sino
    sino = io.readImage( sinofile )
    nang, npix = sino.shape

    print('\nSinogram to reconstruct:\n', sinofile)
    print('Number of projection angles: ', nang)
    print('Number of pixels: ', npix)



    ##  Display sinogram
    if args.plot is True:
        dis.plot( sino , 'Input sinogram' )



    ##  Getting projection geometry  
    ##  Case of equiangular projections distributed in [0,180)
    if args.geometry == '0':
        print('\nDealing with equiangular views distributed in [0,180)')
        angles = np.arange( nang ).astype( myfloat )
        angles[:] = ( angles * 180.0 )/myfloat( nang )

    ##  Case of pseudo polar views
    elif args.geometry == '1':
        print('\nDealing with equally sloped views in [0,180)')
        angles , dump1 , dum2 = create_est_views( nang )
        angles *= 180.0 / np.pi

    ##  Case of list of projection angles in degrees
    else:
        geometryfile = pathin + args.geometry
        print('\nReading list of projection angles: ', geometryfile)
        angles = np.fromfile( geometryfile , sep="\t" )

    print('\nProjection angles:\n', angles)



    ##  Set center of rotation axis
    if args.ctr == None:
        ctr = 0.0
        print('\nCenter of rotation axis placed at pixel: ', npix * 0.5)  
    elif args.ctr == -1:
        ctr = proc.searchCtrRot( sino , None , 'a' )
        print('\nCenter of rotation axis placed at pixel: ', ctr)
        sino = proc.sinoRotAxisCorrect( sino , ctr )
    else:
        ctr = args.ctr
        print('\nCenter of rotation axis placed at pixel: ', ctr)
        sino = proc.sinoRotAxisCorrect( sino , ctr ) 



    ##  Get inverse procedure
    if args.reco_proc == 1:
        proc = args.reco_proc
        print('\nSelected inverse procedure: PCG-IPPFT')

    elif args.reco_proc == 2:
        proc = args.reco_proc
        print('\nSelected inverse procedure: iterative procedure with constraints')   



    ##  Reconstruction with EQUALLY SLOPED TOMOGRAPHY
    print('\nPerforming EST reconstruction ....')
    time_rec1 = time.time()
    reco = est_tomo( sino , angles , proc )
    time_rec2 = time.time()
    print('\n.... reconstruction done!')



    ##  Display reconstruction    
    dis.plot( reco , 'Reconstruction' )


    
    ##  Save reconstruction
    saveReco( reco , pathin , args )

    
    
    ##  Time elapsed for the reconstruction
    time2 = time.time()
    print('\nTime elapsed for the back-projection: ', time_rec2-time_rec1 )
    print('Total time elapsed: ', time2-time1 )


    
    print('\n')
    print('##############################################')
    print('####   EQUALLY SLOPED TOMOGRAPHY DONE !   ####')
    print('##############################################')
    print('\n')
def main():
    ##  Initial print
    print("\n")
    print("##########################################################")
    print("#############   HIERARCHICAL BACKPROJECTION  #############")
    print("##########################################################")
    print("\n")

    ##  Get the startimg time of the reconstruction
    time1 = time.time()

    ##  Get input arguments
    args = getArgs()

    ##  Get input directory
    pathin = args.pathin

    if pathin[len(pathin) - 1] != "/":
        pathin += "/"

    if os.path.exists(pathin) is False:
        sys.exit("\nERROR: input directory ", pathin, " does not exist!")

    print("\nInput directory:\n", pathin)

    ##  Get input sinogram
    sinofile = pathin + args.sino
    sino = io.readImage(sinofile)
    nang, npix = sino.shape

    print("\nSinogram to reconstruct:\n", sinofile)
    print("Number of projection angles: ", nang)
    print("Number of pixels: ", npix)

    ##  Display sinogram
    if args.plot is True:
        dis.plot(sino, "Input sinogram")

    ##  Getting projection geometry
    if args.geometry == "0":
        print("\nDealing with equiangular projections distributed between 0 and" + " 180 degrees ---> [0,180)")
        angles = np.arange(nang).astype(myfloat)
        angles[:] = (angles * 180.0) / myfloat(nang)

    else:
        geometryfile = pathin + args.geometry
        print("\nReading list of projection angles: ", geometryfile)
        angles = np.fromfile(geometryfile, sep="\t")

    if args.plot is True:
        print("\nProjection angles:\n", angles)

    ##  Enable edge padding
    if args.edge_pad is True:
        sino = proc.edgePadding(sino, 0.5)
        i1 = int((sino.shape[1] - npix) * 0.5)
        i2 = i1 + npix
        npix = sino.shape[1]

        if args.plot is True:
            dis.plot(sino, "Edge padded sinogram")

    ##  Set center of rotation axis
    if args.ctr == -1:
        ctr = proc.searchCtrRot(sino, None, "a")
    elif args.ctr == 0:
        ctr = 0.5 * npix
    else:
        ctr = args.ctr
    sino[:, :] = proc.sinoRotAxisCorrect(sino, ctr)

    print("Center of rotation axis placed at pixel: ", ctr)
    print("Center of rotation correction done! ")

    if args.edge_pad is True and ctr != 0.0:
        ctr += i1

    ##  External sinogram filtering
    filt = args.filt

    if filt not in filt_list:
        print(
            "\nERROR: filter named: ', filt,' does not exist!\n \
               Use one of the following available filters:\n \
               'none' , 'ramp' , 'shlo' , 'hann' , 'hamm' , \n \
               'parz' , 'lancz' "
        )

    print("\nSelected filter: ", filt)

    if filt == "none":
        filter_name = "none"
    elif filt == "ramp":
        filter_name = "ramp"
    elif filt == "hann":
        filter_name = "hanning"
    elif filt == "hamm":
        filter_name = "hamming"

    sino = fil.filter_fft(sino, filter_name, 0)
    sino *= 4.0 / myfloat(npix)

    if args.plot is True:
        dis.plot(sino, "Filtered sinogram")

    ##  Set number of pixels of the reconstructed image
    if args.npix_im is None:
        npix_im = npix
    else:
        npix_im = args.npix_im

    if args.base_size == 0:
        base_size = npix
    else:
        base_size = args.base_size

    if args.down_size == 0:
        down_size = npix
    else:
        down_size = args.down_size

    ##  Set parameters
    print("\nFHBP parameter setting:")
    print("Number image pixels: ", npix_im)
    print("Base size: ", base_size)
    print("Downsampling size: ", down_size)
    print("Ratio sinogram / image sampling: ", args.sampl_ratio)

    param = np.array([npix_im, base_size, down_size, args.sampl_ratio])

    ##  Reconstruction with regridding method
    time_rec1 = time.time()
    reco = fhbp.backproj(sino.astype(myfloat), angles.astype(myfloat), param.astype(myfloat))
    time_rec2 = time.time()

    ##  Crop reconstruction
    if args.edge_pad:
        reco = reco[i1:i2, i1:i2]

    ##  Rotate and flip reconstruction
    reco[:, :] = reco[:, ::-1]

    ##  Display reconstruction
    if args.plot is True:
        dis.plot(reco, "Reconstruction")

    ##  Save reconstruction
    write_reconstruction(reco, pathin, args)

    ##  Time elapsed and memory usage for the reconstruction
    time2 = time.time()
    print("\nTime elapsed for the back-projection: ", time_rec2 - time_rec1, " s")
    print("Total time elapsed: ", time2 - time1, " s")

    print("\n")
    print("########################################")
    print("####   FHBP BACKPROJECTION DONE !   ####")
    print("########################################")
    print("\n")