CosmoSim 2.6.8__tar.gz → 2.8.0__tar.gz

{cosmosim-2.6.8 → cosmosim-2.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CosmoSim
-Version: 2.6.8
+Version: 2.8.0
 Summary: Simulator of Gravitational Lenses
 Author: Hans Georg Schaathun et al
 Author-email: Hans Georg Schaathun <georg+github@schaathun.net>

{cosmosim-2.6.8 → cosmosim-2.8.0}/src/CosmoSim/CosmoSim.cpp

@@ -226,9 +226,9 @@ void CosmoSim::configLens() {
          psilens->setRatio( ellipseratio ) ;
          psilens->setOrientation( orientation ) ;
       }
-      if (DEBUG) std::cout << "[runSim] ready for initAlphasBetas\n" ;
+      if (DEBUG) std::cout << "[configLens] ready for initAlphasBetas\n" ;
       psilens->initAlphasBetas() ;
-      if (DEBUG) std::cout << "[runSim] done initAlphasBetas\n" ;
+      if (DEBUG) std::cout << "[configLens] done initAlphasBetas\n" ;
    }
 
    std::cout << "[initLens] ready to sample lens\n" ;

{cosmosim-2.6.8 → cosmosim-2.8.0}/src/CosmoSim/Image.py

@@ -1,5 +1,5 @@
 #! /usr/bin/env python3
-# (C) 2022: Hans Georg Schaathun <georg@schaathun.net> 
+# (C) 2022-26: Hans Georg Schaathun <georg@schaathun.net> 
 
 """
 Post-processing functions for images.
@@ -9,7 +9,40 @@ import numpy as np
 import cv2
 import argparse
 
-def centreImage(im,newbehaviour=True):
+
+def imageCoordinate( pt, im ):
+    nrows, ncols = im.shape[:2]
+    (x,y) = pt
+    return (  round(x + ncols/2), round(nrows/2 - y) )
+
+def annotateCircle(im,pt,radius,colour=(0,0,255)):
+    """
+    Mark a point on an image.
+    This is crude and should be extended with different shapes as
+    well as text.
+    """
+    if len(im.shape) == 2:
+        im = cv2.cvtColor(im, cv2.COLOR_GRAY2BGR)
+    pt = imageCoordinate( pt, im )
+    print( "Annotation at", pt, "colour", colour )
+    im = cv2.circle(im,center=pt,radius=round(radius),color=colour, thickness=1)
+    return im
+def annotatePoint(im,pt,colour=(0,0,255)):
+    """
+    Mark a point on an image.
+    This is crude and should be extended with different shapes as
+    well as text.
+    """
+    if len(im.shape) == 2:
+        im = cv2.cvtColor(im, cv2.COLOR_GRAY2BGR)
+    r = 4
+    pt = imageCoordinate( pt, im )
+    print( "Annotation at", pt, "colour", colour )
+    im = cv2.circle(im,center=pt,radius=r,color=colour, thickness=1)
+    im = cv2.circle(im,center=pt,radius=1,color=colour, thickness=-1)
+    return im
+
+def centreImage(im):
   """
   Shift an image so that the centre of luminence is the centre of the image.
 
@@ -31,7 +64,7 @@ def centreImage(im,newbehaviour=True):
 
   if s == 0: 
       centred = im
-      (xm,ym) = (0,0)
+      pt = (0,0)
   else:
       xcol = np.array(range(m))[:,np.newaxis]
       yrow = np.array(range(n))[np.newaxis,:]
@@ -39,34 +72,34 @@ def centreImage(im,newbehaviour=True):
       ys = yrow*grey
       xm = xs.sum()/s - m/2
       ym = ys.sum()/s - n/2
-      print( "Translation", (xm,ym) )
-
-      if newbehaviour:
-          R = np.float32( [ [ 1, 0, -ym ], [ 0, 1, -xm ] ] )
-          centred = cv2.warpAffine(im,R,(n,m))
-      else:
-          xm = int(round(xm))
-          ym = int(round(ym))
-          print( "Integer Translation", (xm,ym) )
-          centred = np.zeros( im.shape )
-          c1 = np.zeros( im.shape )
-   
-          if xm > 0:
-             c1[:-xm,:] = im[xm:,:]
-          elif xm < 0:
-             c1[-xm:,:] = im[:xm,:]
-          else:
-             c1 = im
-          if ym > 0:
-             centred[:,:-ym] = c1[:,ym:]
-          elif ym < 0:
-             centred[:,-ym:] = c1[:,:ym]
-          else:
-             centred = c1
-
-  print( f"Centre: ({xm},{ym}) ;  " 
-       + f"Range ({centred.min()},{centred.max()})" )
-  return (centred,(ym,-xm))
+      pt = (ym,-xm)
+      centred = translateImage(im,pt)
+
+  return (centred,pt)
+
+def translateImage(im,pt):
+    (ym,xm) = pt
+    R = np.float32( [ [ 1, 0, -ym ], [ 0, 1, xm ] ] )
+    if len(im.shape) > 2:
+        m,n,_ = im.shape
+    else:
+        m,n = im.shape
+    return cv2.warpAffine(im,R,(n,m))
+
+def crop(im,cropsize=256):
+    (m,n) = im.shape[:2]
+    if cropsize < min(m,n):
+        assert m == n
+        c = (m-cropsize)/2
+        c1 = int(np.floor(c))
+        c2 = int(np.ceil(c))
+        if len(im.shape) == 2:
+            im = im[c1:-c2,c1:-c2]
+        else:
+            im = im[c1:-c2,c1:-c2,:]
+        assert cropsize == im.shape[0]
+        assert cropsize == im.shape[1]
+    return im
 
 def drawAxes(im):
   m,n = im.shape[:2]

{cosmosim-2.6.8 → cosmosim-2.8.0}/src/CosmoSim/Parameters.py

@@ -17,7 +17,7 @@ class Parameters:
         if args:
             self._args = args
         else:
-            self._args = CosmoParser().parse_args()
+            self._args = Args()
         self._row = {}
         if cfg:
             cfg1 = cfg["simulator"]
@@ -32,14 +32,14 @@ class Parameters:
                     self._args.source = None
     def setRow(self,row):
         self._row = row
-    def get(self,key,default=None):
+    def get(self,key,default=None,verbose=0):
         if self._args is None:
             r = default
         else:
             try:
                 r = self._args.__dict__[key]
             except KeyError:
-                print( self._args )
+                if verbose > 1: print( self._args )
                 r = default
         r = self._row.get(key,r)
         return r

cosmosim-2.8.0/src/CosmoSim/Simulator.py

@@ -0,0 +1,149 @@
+#! /usr/bin/env python3
+# (C) 2026: Hans Georg Schaathun <georg@schaathun.net>
+
+"""
+Simulator class to manage bulk image generation.
+
+Different subclasses are required for different backend simulators, like
+`RouletteRegenerator` and `CosmoSim`.
+The `GenericSim` superclass contains shared methods.
+
+The constructor may takes a data row, typically a pandas Series object,
+reconfigures the backend simulator, and generates the distorted image.
+Since the object retains much of the simulation data, extensive information
+and annotated images may be retrieved as well.
+
+The constructor may take a backend simulator instance as parameter.  This saves
+the cost of reinstantiation in bulk simulation, and it also leaves the possibility
+to set defaults in advance.
+"""
+
+import tomllib as tl
+
+import cv2 as cv
+import sys
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+from . import CosmoSim
+
+from .Image import centreImage, drawAxes, crop, annotatePoint, annotateCircle, translateImage
+
+from .Arguments import CosmoParser
+from .Parameters import Parameters
+import pandas as pd
+
+defaultoutcols = [ "index", "filename", "source", "lens", "chi", "R", "phi", "einsteinR", "sigma", "sigma2", "theta", "x", "y" ]
+
+class GenericSim:
+    """
+    This is a generic superclass for shared methods.
+    """
+    def __init__(self,param=None,row=None,name=None,outcols=None,verbose=1):
+        if verbose > 0: print( "[GenericSim] init ..." )
+        self.verbose = verbose
+
+        self.outcols = outcols
+
+        self.name = name
+        if param is None: 
+            print( "[GenericSim] No parameters give. Using defaults" )
+            param = Parameters()
+        self.param = param
+        self.directory = param.get( "directory" )
+        if self.directory:
+            os.makedirs( self.directory, exist_ok=True )
+
+    def setParameters(self,row):
+        """
+        Reset parameters in the backend simulator, using the given data row.
+        This is an auxiliary for `initSim()` and will normally have to be 
+        overridden depending on the class of the backend simulator.
+        """
+        raise NotImplementedError()
+    def initSim(self,row):
+        """
+        Run the simulator with the given data row.
+        """
+        if not row is None:
+            if self.verbose: print( "[initSim] using row" )
+            self.setParameters( row )
+            if self.verbose: print( "index", row.get( "index", None ) )
+            self.param.setRow( row )
+            try:
+                name = row.name.split(".")[0]
+            except:
+                name = row["filename"].split(".")[0]
+            self.row = row
+            self.name = name
+        elif self.verbose: print( "[initSim] row is None" )
+        if self.name is None:
+            self.name = self.param.get( "name" )
+        if self.verbose: print( "[initSim] item name:", self.name )
+
+        self.runSim()
+
+        self.image = self.getDistortedImage( )
+        (self.centreimage,self.centrepoint) = centreImage(self.image)
+        print( "[datagen.py] Centre Point", self.centrepoint,
+              "(Centre of Luminence in Planar Co-ordinates)" )
+    def getDistortedImage(self):
+        return  self.sim.getDistortedImage( 
+                         critical=self.param.get( "criticalcurves" ),
+                         showmask=self.param.get( "showmask" ) ) 
+    def setParameters(self):
+        raise Exception("Not implemented")
+    def runSim(self):
+        if self.verbose: print( "[runSim]" )
+        self.sim.makeSource( self.param )
+        if self.verbose > 0: print ( "[initSim] ready for runSim()\n" ) ;
+        self.sim.runSim()
+        if self.verbose > 0: print ( "[initSim] runSim() completed\n" ) ;
+    def getActual(self):
+        param = self.param
+        name = self.name
+        fn = os.path.join(param.get("directory"),"actual-" + str(name) + ".png" ) 
+        im = self.sim.getActualImage( reflines=param.get( "reflines" ) )
+        cv.imwrite(fn,im)
+    def getApparent(self):
+        param = self.param
+        name = self.name
+        fn = os.path.join(param.get("directory"),"apparent-" + str(name) + ".png" ) 
+        im = self.sim.getApparentImage( reflines=param.get( "reflines" ) )
+        cv.imwrite(fn,im)
+    def getAnnotated(self,centred=None,cropsize=None):
+        """
+        Stub for a future function to get an image with annotations.
+        """
+        im = self.sim.getDistortedImage( critical=True )
+        im = annotatePoint( im, self.centrepoint, colour=( 64, 255, 64 ) )
+        pt = self.sim.getXiOffset( (0,0) )
+        im = annotatePoint( im, pt, colour=( 64, 64, 255 ) )
+        x, y = pt
+        convradius = np.sqrt( x*x + y*y )
+        im = annotateCircle( im, pt, radius=convradius, colour=( 64, 64, 255 ) )
+        return im
+    def getImage(self,centred=None,cropsize=None):
+        param = self.param
+        if centred is None: centred = param.get( "centred" )
+        if centred:
+            im = self.centreimage
+        else:
+            im = self.image
+        if cropsize is None: cropsize = param.get( "cropsize" )
+        if cropsize:
+            im = crop(im,int( param.get( "cropsize" ) ))
+        if param.get( "reflines" ):
+            drawAxes(im)
+        return im
+    def saveImage(self,name=None):
+        im = self.getImage()
+        if name is None:
+            name = self.name
+        if self.directory is None:
+            fn = str(name) + ".png"
+        else:
+            fn = os.path.join(self.directory, str(name) + ".png" )
+        if self.verbose: print( "[saveImage]", fn )
+        cv.imwrite(fn,im)

{cosmosim-2.6.8 → cosmosim-2.8.0}/src/CosmoSim/__init__.py

@@ -12,14 +12,42 @@ import os, sys
 
 import traceback
 
-__version__ = "2.6.8"
+__version__ = "2.8.0"
 
 ModelSpec = cs.ModelSpec
 SourceSpec = cs.SourceSpec
 PsiSpec = cs.PsiSpec
 LightProfileSpec = cs.LightProfileSpec
 
-RouletteRegenerator = cs.RouletteRegenerator 
+class RouletteRegenerator(cs.RouletteRegenerator):
+    def __init__(self,*a,**kw):
+        super().__init__(*a,**kw)
+        self.bgcolour = 0
+    def makeSource(self,param):
+        if param.get( "imagesize" ) is None:
+            raise Exception( "Image size not specified" )
+        self._src = makeSource(param)
+        self.setSource( self._src )
+        print( "RouletteRegenerator.makeSource() returns" )
+    def getDistortedImage(self,reflines=False,critical=False,mask=False,showmask=False):
+        """
+        Return the Distorted Image from the simulator as a numpy array.
+        """
+        try:
+            if mask: self.maskImage()
+            if showmask: self.showMask()
+        except:
+            print( "Masking not supported for this lens model." )
+        try:
+            im = np.array(self.getDistorted(),copy=False)
+        except Exception as e:
+            print( "self", type(self) )
+            print( "reflines", reflines )
+            print( "critical", critical )
+            im = np.array(self.getDistorted(),copy=False)
+            raise e
+        if im.shape[2] == 1 : im.shape = im.shape[:2]
+        return np.maximum(im,self.bgcolour)
 Point = cs.Point 
 
 def makeSourceConstellation(src,size):
@@ -376,50 +404,14 @@ class CosmoSim(cs.CosmoSim):
             if showmask: self.showMask()
         except:
             print( "Masking not supported for this lens model." )
-        im = np.array(self.getDistorted(reflines,critical),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-class RouletteSim:
-    """
-    Simulator for gravitational lensing.
-    This wraps the CosmoSim library written in C++.  In particular,
-    it wraps functions returning images, to convert the data to 
-    numpy arrays.
-    """
-    def __init__(self,*a,maxm=50,**kw):
-        super().__init__(*a,**kw)
-
-        self.bgcolour = 0
-
-    def setBGColour(self,s):
-        self.bgcolour = s
-
-    def getApparentImage(self,reflines=True):
-        """
-        Return the Apparent Image from the simulator as a numpy array.
-        """
-        im = np.array(self._rsim.getApparent(),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-    def getActualImage(self,reflines=True,caustics=False):
-        """
-        Return the Actual Image from the simulator as a numpy array.
-        """
-        im = np.array(self._rsim.getActual(),copy=False)
-        if im.shape[2] == 1 : im.shape = im.shape[:2]
-        return np.maximum(im,self.bgcolour)
-    def initSim(self,rsim):
-        self._rsim = rsim
-
-    def getDistortedImage(self,reflines=False,mask=False,showmask=False):
-        """
-        Return the Distorted Image from the simulator as a numpy array.
-        """
         try:
-            if mask: self._rsim.maskImage()
-            if showmask: self._rsim.showMask()
-        except:
-            print( "Masking not supported for this lens model." )
-        im = np.array(self._rsim.getDistorted(),copy=False)
+            im = np.array(self.getDistorted(reflines,critical),copy=False)
+        except Exception as e:
+            print( "self", type(self) )
+            print( "reflines", reflines )
+            print( "critical", critical )
+            im = np.array(self.getDistorted(),copy=False)
+            raise e
         if im.shape[2] == 1 : im.shape = im.shape[:2]
         return np.maximum(im,self.bgcolour)
+

{cosmosim-2.6.8 → cosmosim-2.8.0}/src/CosmoSim/datagen.py

@@ -13,8 +13,9 @@ import os
 import numpy as np
 import matplotlib.pyplot as plt
 from .dataset import datasetgen
+from .Simulator import GenericSim
 
-from .Image import centreImage, drawAxes
+from .Image import centreImage, drawAxes, crop, annotatePoint, annotateCircle, translateImage
 from . import getMSheaders,CosmoSim,__version__
 
 from .Arguments import CosmoParser
@@ -27,7 +28,7 @@ def setParameters(sim,row,verbose=1):
     if verbose > 2:
        print( "[datagen.py] setParameters()" )
        print( row ) 
-    if row.get("y",None) != None:
+    if row.get("y") is not None:
         if verbose > 1: print( "XY", row["x"], row["y"] )
         sim.setXY( row["x"], row["y"] )
     elif row.get("phi",None) != None:
@@ -59,42 +60,31 @@ def setParameters(sim,row,verbose=1):
         sim.setNterms( row["nterms"] )
 
 
-class SimImage:
+class SimImage(GenericSim):
     """
     This class simulates a single image.
     Once the simulation has been run, various kinds of image and metadata can be
     retrieved from the object.
     """
-    def __init__(self,sim,param,name=None,row=None,outcols=None,verbose=1):
-        if verbose > 0: print( "[SimImage] init ..." )
-        if param is None: param = Parameters()
-        self.verbose = verbose
-        if not row is None:
-            setParameters( sim, row )
-            print( "index", row["index"] )
-            param.setRow( row )
-            name = row["filename"].split(".")[0]
-            self.row = row
-        elif name == None:
-            name = param.get( "name" )
-        sim.makeSource( param )
-        if verbose > 0: print ( "[datagen.py] ready for runSim()\n" ) ;
-        sim.runSim()
-        if verbose > 0: print ( "[datagen.py] runSim() completed\n" ) ;
-        centrepoint = makeOutput(sim,param,name)
-        print( "[datagen.py] Centre Point", centrepoint,
-              "(Centre of Luminence in Planar Co-ordinates)" )
+    def __init__(self,sim=None,row=None,**kw):
+        super().__init__(**kw)
+
+        if sim is None: sim = CosmoSim()
         self.sim = sim
-        self.centrepoint = centrepoint
-        self.name = name
-        self.param = param
-        self.directory = self.param.get( "directory" )
-        if self.directory:
-            os.makedirs( self.directory, exist_ok=True )
-        self.outcols = outcols
+        self.initSim(row)
+
+    def setParameters(self,row):
+        """
+        Reset parameters in the underlying `CosmoSim` simulator, using the
+        given data row.
+        """
+        return setParameters(self.sim,row)
     def getData(self):
         sim = self.sim
-        centrepoint = self.centrepoint
+        if self.param( "centred" ):
+            centrepoint = self.centrepoint
+        else:
+            centrepoint = (0,0)
         maxm = self.param.get( "nterms" )
         xireference = self.param.get( "xireference" )
         if self.verbose > 0:
@@ -122,6 +112,11 @@ class SimImage:
             print( r1 )
         return r1
     def join(self):
+        """
+        Merge images simulated different reference points for
+        the roulette expansion.  This has not been tested since the early
+        work where we tried to get accurate simulations using roulette. 
+        """
         # sim.setMaskMode(False)
         sim = self.sim
         maskscale = float(self.param.get( "maskscale" ))
@@ -141,15 +136,41 @@ class SimImage:
             drawAxes(joinim)
         cv.imwrite(fn,joinim)
     def family(self):
+        """
+        Run a family of simulations with different reference points for
+        the roulette expansion.  This has not been tested since the early
+        work where we tried to get accurate simulations using roulette. 
+        """
         sim = self.sim
-        sim.moveSim(rot=-np.pi/4,scale=1)
-        makeOutput(sim,self.param,name=f"{self.name}-45+1")
-        sim.moveSim(rot=+np.pi/4,scale=1)
-        makeOutput(sim,self.param,name=f"{self.name}+45+1")
-        sim.moveSim(rot=0,scale=-1)
-        makeOutput(sim,self.param,name=f"{self.name}+0-1")
-        sim.moveSim(rot=0,scale=2)
-        makeOutput(sim,self.param,name=f"{self.name}+0+2")
+        self.moveImage(rot=-np.pi/4,scale=1,name=f"{self.name}-45+1")
+        self.moveImage(rot=+np.pi/4,scale=1,name=f"{self.name}+45+1")
+        self.moveImage(rot=0,scale=-1,name=f"{self.name}+0-1")
+        self.moveImage(rot=0,scale=2,name=f"{self.name}+0+2")
+    def moveImage(self,rot,scale,name):
+        """
+        Simulate with a different reference point.  This only makes
+        sense for roulette models.
+        """
+        sim = self.sim
+        param = self.param
+        sim.moveSim(rot,scale)
+        im = sim.getDistortedImage( 
+                 critical=param.get( "criticalcurves" ),
+                 showmask=param.get( "showmask" ) ) 
+        print( "getDistortedImage() has returned", type(im) )
+
+        if param.get( "centred" ):
+            (im,(cx,cy)) = centreImage(im)
+        if param.get( "cropsize" ):
+            im = crop(im,int( param.get( "cropsize" ) ))
+        if param.get( "reflines" ):
+            drawAxes(im)
+
+        fn = os.path.join(param.get("directory"), str(name) + ".png" ) 
+        cv.imwrite(fn,im)
+        return im
+
+
     def psiplot(self):
         a = self.sim.getPsiMap()
         print(a.shape, a.dtype)
@@ -175,62 +196,23 @@ class SimImage:
         fn = os.path.join(self.directory,"kappa-" + str(self.name) + ".svg" ) 
         plt.savefig( fn )
         plt.close()
+
 def makeSingle(sim,param=None,name=None,row=None,outcols=None):
     """Process a single parameter set, given either as a pandas row or
     just as args parsed from the command line.
     """
     if param is None: param = Parameters()
-    imsim = SimImage(sim,param,name,row,outcols)
+    imsim = SimImage(sim,param=param,name=name,row=row,outcols=outcols)
+    imsim.saveImage()
     if param.get( "join" ): imsim.join()
     if param.get( "family" ): imsim.family()
     if param.get( "psiplot" ): imsim.psiplot()
     if param.get( "kappaplot" ): imsim.psiplot()
+    if param.get( "apparent" ): imsim.getApparent()
+    if param.get( "actual" ): imsim.getActual()
     print( "makeSingle() returns" )
     return imsim
 
-def crop(im,cropsize=256):
-    (m,n) = im.shape
-    if cropsize < min(m,n):
-            assert m == n
-            c = (m-cropsize)/2
-            c1 = int(np.floor(c))
-            c2 = int(np.ceil(c))
-            im = im[c1:-c2,c1:-c2]
-            assert cropsize == im.shape[0]
-            assert cropsize == im.shape[1]
-    return im
-def makeOutput( sim,param,name=None,rot=0,scale=1 ):
-
-    im = sim.getDistortedImage( critical=param.get( "criticalcurves" ), showmask=param.get( "showmask" ) ) 
-    print( "getDistortedImage() has returned" )
-
-    (cx,cy) = 0,0
-    if param.get( "centred" ):
-        (centreIm,(cx,cy)) = centreImage(im)
-        if param.get( "original" ):
-           fn = os.path.join(param.get( "directory","original-" + str(name) + ".png" ))
-           if param.get( "reflines" ): drawAxes(im)
-           cv.imwrite(fn,im)
-        im = centreIm
-    if param.get( "cropsize" ):
-        im = crop(im,int( param.get( "cropsize" ) ))
-    if param.get( "reflines" ):
-        drawAxes(im)
-
-    fn = os.path.join(param.get("directory"), str(name) + ".png" ) 
-    cv.imwrite(fn,im)
-
-    if param.get( "actual" ):
-       fn = os.path.join(param.get("directory"),"actual-" + str(name) + ".png" ) 
-       im = sim.getActualImage( reflines=param.get( "reflines" ) )
-       cv.imwrite(fn,im)
-    if param.get( "apparent" ):
-       fn = os.path.join(param.get("directory"),"apparent-" + str(name) + ".png" ) 
-       im = sim.getApparentImage( reflines=param.get( "reflines" ) )
-       cv.imwrite(fn,im)
-    return (cx,cy)
-
-
 def main(args):
     print( "[datagen.py] Instantiate Simulator ... " )
     sys.stdout.flush()