roman-snpit-snappl 0.20.0__tar.gz → 0.21.0__tar.gz

{roman_snpit_snappl-0.20.0/roman_snpit_snappl.egg-info → roman_snpit_snappl-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.20.0
+Version: 0.21.0
 Summary: General, database, and photometry utilities for the Roman SNPIT
 Author: Roman Supernova Project Infrastructure Team
 Maintainer-email: Roman SN PIT <raknop@lbl.gov>

roman_snpit_snappl-0.21.0/changes/98.docs.rst

@@ -0,0 +1 @@
+Add lightcurve reading and writing to the nov 2025 primer in the usage docs

roman_snpit_snappl-0.21.0/changes/99.feature.rst

@@ -0,0 +1 @@
+Add storage and database tracking of segmentation maps

{roman_snpit_snappl-0.20.0 → roman_snpit_snappl-0.21.0}/docs/usage.rst

@@ -145,6 +145,14 @@ However, we recommend against that.  While 4500 is perhaps not an overwhelming n
 Finding Objects
 ===============
 
+You may just be given an diaobject id.  In that case, all you have to do is::
+
+  from snappl.diaobject import DiaObject
+
+  obj = DiaObject.get_object( diaobject_id=<id> )
+
+where ``<id>`` is the diaobject id you were given.  ``obj`` will be a ``DiaObject`` object.
+
 There is also an interface that lets you find objects.  For instance, if you want to find all objects within 100 arcseconds of a given location, you could run::
 
   from snappl.diaobject import DiaObject
@@ -158,7 +166,7 @@ Here, you can use ``ou2024`` for ``TAG`` and ``load_ou2024_diaobject`` for ``PRO
 Getting Better Object Positions
 ===============================
 
-``DiaObject.find_objects`` will return a list of ``DiaObject`` objects, and these include properties ``ra`` and ``dec``.  **However, the positions in the DiaObject object should be viewed as approximate.**  They will be the position it had when the object was first discovered.  For objects loaded from truth tables, they will be perfect, but of course we won't have truth tables for the real survey.  Often, the first discovery will be a relatively low S/N point, and much better positions can be determined; doing so will be one of the jobs of ``phrosty``.
+The ``DiaObject`` you got from ``DiaObject.get_object`` or ``DiaObject.find_object`` include properties ``ra`` and ``dec``.  **However, the positions in the DiaObject object should be viewed as approximate.**  They will be the position it had when the object was first discovered.  For objects loaded from truth tables, they will be perfect, but of course we won't have truth tables for the real survey.  Often, the first discovery will be a relatively low S/N point, and much better positions can be determined; doing so will be one of the jobs of ``phrosty``.
 
 To get an improved position for an object, assume you have the object in the variable ``diaobj``.  You can then call::
 
@@ -181,10 +189,36 @@ See :ref:`nov2025-provtags` below to figure out what ``TAG`` and ``PROCESS`` sho
 **Important**: if you use an updated DiaObject position, then the provenance of that position should be one of your upstream provenances; see :ref:`nov2025-making-prov`.
 
 
-Finding Lightcurves
+Reading Lightcurves
 ===================
 
-TODO
+To read a lightcurve, you need three or four things:
+
+  * The ``diaobject_id`` of the object whose lightcurve you want
+  * The ``provenance_tag`` of the provenance you want to get lightcurves from
+  * The ``process`` to go with the provenance tag
+  * (Optional) The ``band`` of the lightcurve
+
+The ``provenance_tag`` and ``process`` will be given to you through our fake orchestration process, and may possibly be found in :ref:`nov2025-provtags`.  The ``diaobject_id`` will be given to you through the fake orchestration process.
+
+To get the lightcurves::
+
+  from snappl.lightcurve import Lightcurve
+
+  ltcvs = Lightcurve.find_lightcurves( <diaobject_id>, provenance_tag=<tag>, process=<proc>, dbclient=dbclient )
+
+That will return a list of lightcurves.  If you also specify ``band=<band>``, that will be a 1-element list with the lightcurve just for that band.  (Or a 0-element list if it's not found.)
+
+Each element of the list will be a ``Lightcurve`` object.  You can find the actual lightcurve data in the ``.lightcurve`` property as an astropy QTable.  You can find the metadata dictionary either in the ``.lightcurve.meta`` or in the ``.meta`` property (though the latter will intially be ``None`` until you access the ``.lightcurve`` property).  Guaranteed metadata can be found in the `lightcurve schema specification on the PIT wiki <https://github.com/Roman-Supernova-PIT/Roman-Supernova-PIT/wiki/lightcurve>`_.  You should probably ignore the ``filepath`` in the metadata, because ``snappl`` has already read the file for you (and put it in the ``.lightcurve`` property).
+
+
+Finding Segmentation Maps
+=========================
+
+You will need to ``from snappl.segmap import SegmentationMap`` and then call ``SegmentationMap.find_segmaps``.  You need to pass a provenance tag and a process to ``find_segmaps``; you will be given these (see :ref:`nov2025-provtags`).  Beyond that, look at the docstring for that function to see what you can search on.
+
+You will get back a list of ``SegmentationMap`` objects.  A ``SegmentationMap`` object has several attributes, including ``band``, and eight attributes ``ra_corner_00``, ``dec_corner_00``, etc., where ``00`` is the lower-left pixel, ``01`` upper-left pixel, ``10`` is the lower-right pixel, and ``11`` is the upper-right pixel.  The most important field is ``.image``.  This is a ``snappl.image.Image`` object.  You can get the 2d numpy array of the image data of the segmentaton map from the ``.data`` property of the ``Image`` object.
+
 
 .. _nov2025-making-prov:
 
@@ -250,9 +284,24 @@ This will (I believe) return a dictionary that's the same as what you'd get back
 Saving Lightcurves
 ==================
 
-TODO
+Lightcurves saved to the database are for only a single band.  If you have a multiband lightcurve, from the point of view of the database that's several different lightcurves.
+
+To write a Lightcurve, first create a ``Lightcurve`` object::
+
+  from snappl.lightcurve import Lightcurve
+
+  ltcv = Lightcurve( data=<data>, meta=<meta> )
+
+where ``<meta>`` is a dictionary with metadata, and ``<data>`` is one of an astropy Table, a pandas DataFrame, or a dictionary of lists.  On the `lightcurve schema specification on the PIT wiki <https://github.com/Roman-Supernova-PIT/Roman-Supernova-PIT/wiki/lightcurve>`_ you can find the mandatory fields in the metadata dictionary; it's allowed to have additional ones as well.  Likewise, there you can find the mandatory columns (and the order of those columns) in the data array.  You may also have additional columns in that data array.
+
+In order to create a lightcurve, you will need to make a provenance for it; see :ref:`nov2025-making-prov`.  Make sure to include the ``diaobject position`` provenance as an upstream provenance if you used a position other than the cheesy approximate one that comes with the ``DiaObject``.
+
+Once you have your lightcurve object, do two things::
 
+  ltcv.write()
+  ltcv.save_to_db( dbclient=dbclient )
 
+The first one writes the actual file; it will write it in the standard location, and will populate the ``.filepath`` property with the location of the file *relative to the configured base directory for lightcurves* (which is in config option ``system.paths.lightcurves``).  The second call saves a record to the database with information about your lightcurve.
 
 .. _nov2025-provtags:
 

{roman_snpit_snappl-0.20.0 → roman_snpit_snappl-0.21.0/roman_snpit_snappl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roman_snpit_snappl
-Version: 0.20.0
+Version: 0.21.0
 Summary: General, database, and photometry utilities for the Roman SNPIT
 Author: Roman Supernova Project Infrastructure Team
 Maintainer-email: Roman SN PIT <raknop@lbl.gov>

{roman_snpit_snappl-0.20.0 → roman_snpit_snappl-0.21.0}/roman_snpit_snappl.egg-info/SOURCES.txt

@@ -70,6 +70,8 @@ changes/9.snappl.rst
 changes/91.feature.rst
 changes/92.docs.rst
 changes/94.snappl.rst
+changes/98.docs.rst
+changes/99.feature.rst
 docker/postgres/Dockerfile
 docker/postgres/postgresql.conf
 docker/postgres/run_postgres.sh
@@ -115,6 +117,7 @@ snappl/logger.py
 snappl/provenance.py
 snappl/psf.py
 snappl/sed.py
+snappl/segmap.py
 snappl/utils.py
 snappl/wcs.py
 snappl/_dev/__init__.py
@@ -129,6 +132,7 @@ snappl/db/migrations/20251008_init.sql
 snappl/db/migrations/20251017_objdetcount.sql
 snappl/db/migrations/20251024_l2image_mjd.sql
 snappl/db/migrations/20251025_lightcurve.sql
+snappl/db/migrations/20251028_segmap.sql
 snappl/db/migrations/apply_migrations.py
 snappl/db/migrations/schema_to_rst.py
 snappl/db/migrations/scorched_earth.py

{roman_snpit_snappl-0.20.0 → roman_snpit_snappl-0.21.0}/snappl/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.20.0'
-__version_tuple__ = version_tuple = (0, 20, 0)
+__version__ = version = '0.21.0'
+__version_tuple__ = version_tuple = (0, 21, 0)
 
-__commit_id__ = commit_id = 'g3f6286e64'
+__commit_id__ = commit_id = 'g7a9941597'

roman_snpit_snappl-0.21.0/snappl/db/baseview.py

@@ -0,0 +1,266 @@
+from types import SimpleNamespace
+import simplejson
+
+import flask
+import flask.views
+from psycopg import sql
+
+from snappl.db import db
+from snappl.logger import SNLogger
+from snappl.utils import SNPITJsonEncoder
+
+
+# ======================================================================
+
+class BaseView( flask.views.View ):
+    """A BaseView that all other views can be based on.
+
+    If the view doesn't override dispatch_request, then it must define a
+    function do_the_things.  That should return a dict, list, string,
+    tuple, or ...something else.
+
+    If it returns a dict or a list, the web server will send to the
+    client application/json with status 200. If the result is a string,
+    it the web server will send to the client text/plain with status
+    200.  If it's a tuple, just let Flask deal with that tuple to figure
+    out what the web server should send to the client.  Otherwise, the
+    web server will send to the client application/octet-stream with
+    status 200.
+
+    Subclasses that do not override dispatch_request do not need to call
+    check_auth.  However, if they do override it, they should call that
+    if the results shouldn't be sent back to an unauthenticated user.
+
+    """
+
+    _admin_required = False
+
+    def __init__( self, *args, **kwargs ):
+        super().__init__( *args, **kwargs )
+
+
+    def check_json_keys( self, needed_keys, allowed_keys, minmax_keys=set() ):
+        if not flask.request.is_json:
+            raise RuntimeError( "Expected json POST data, didn't get any." )
+
+        all_allowed_keys = allowed_keys.copy()
+        for kw in minmax_keys:
+            for edge in [ 'min', 'max' ]:
+                all_allowed_keys.add( f"{kw}_{edge}" )
+
+        data = flask.request.json
+        passed_keys = set( data.keys() )
+        if not needed_keys.issubset( passed_keys ):
+            raise RuntimeError( f"Missing required keys: {needed_keys - passed_keys}" )
+        if not passed_keys.issubset( all_allowed_keys ):
+            raise RuntimeError( f"Unknown keys: {passed_keys - all_allowed_keys}" )
+        return data
+
+    def get_provenance_id( self, data, dbcon=None ):
+        with db.DBCon( dictcursor=True ) as dbcon:
+            provid = None
+            if 'provenance' in data:
+                provid = data['provenance']
+                del data['provenance']
+            elif ( 'provenance_tag' in data ) and ( 'process' in data ):
+                rows = dbcon.execute( "SELECT provenance_id FROM provenance_tag "
+                                      "WHERE tag=%(tag)s AND process=%(proc)s",
+                                      {'tag': data['provenance_tag'], 'proc': data['process'] } )
+                if len(rows) == 0:
+                    raise RuntimeError( f"Unknown provenance with tag {data['provenance_tag']} "
+                                        f"and process {data['process']}" )
+                if len(rows) > 1:
+                    raise RuntimeError ( f"Database corruption: multiple provenances with tag {data['provenance_tag']}"
+                                         f"and process {data['process']}; this should never happen." )
+                provid = db.Provenance.get( rows[0]['provenance_id'] ).id
+                del data['provenance_tag']
+                del data['process']
+            else:
+                raise RuntimeError( "Must give either provenance_id, or both of provenance_tag and process" )
+
+            return data, provid
+
+
+    # Warning : only call this next one if you've made sure that there is no SQL injection in keys!
+    def build_sql_insert( self, keys ):
+        keysql = None
+        subs = None
+        for key in keys:
+            if keysql is None:
+                keysql = sql.SQL( "{key}" ).format( key=sql.Identifier( key ) )
+            else:
+                keysql += sql.SQL( ", {key}" ).format( key=sql.Identifier( key ) )
+            if subs is None:
+                subs = f"%({key})s"
+            else:
+                subs += f", %({key})s"
+        return keysql, subs
+
+
+    # WARNING.  Do not use this unless you're sure that everything in
+    #   the passed arrays have no SQL injection attacks.
+    def make_sql_conditions( self, data, equalses=[], minmaxes=[],
+                             q3ctriplets=[], cornerpolypairs=[],
+                             conditions=[], subdict={} ):
+        finalclause = None
+
+        if any( i in data for i in [ 'order_by', 'limit', 'offset' ] ):
+            orderbyclause = None
+            limitclause = None
+            offsetclause = None
+
+            if 'order_by' in data:
+                orderby = data['order_by']
+                if not isinstance( orderby, list ):
+                    orderby = [ orderby ]
+                orderbyclause = sql.SQL( " ORDER BY " )
+                comma = ""
+                for o in orderby:
+                    orderbyclause += sql.SQL( f"{comma}{{orderby}}" ).format( orderby=sql.Identifier(o) )
+                    comma = ","
+                del data['order_by']
+                finalclause = orderbyclause
+
+            if 'limit' in data:
+                limitclause = sql.SQL( " LIMIT %(finalclause_limit)s" )
+                subdict['finalclause_limit'] = data['limit']
+                del data['limit']
+                if finalclause is None:
+                    finalclause = limitclause
+                else:
+                    finalclause += limitclause
+
+            if 'offset' in data:
+                offsetclause = sql.SQL( " OFFSET %(finalclause_offset)s" )
+                subdict['finalclause_offset'] = data['offset']
+                del data['offset']
+                if finalclause is None:
+                    finalclause = offsetclause
+                else:
+                    finalclause += offsetclause
+
+        finalclause = sql.SQL("") if finalclause is None else finalclause
+
+        for i, triplet in enumerate(q3ctriplets):
+            presencecheck = [ ( i in data and data[i] is not None ) for i in triplet ]
+            if any( presencecheck ):
+                if not all( presencecheck ):
+                    raise RuntimeError( f"Must include all or none of {triplet}" )
+                barf = f"q3c_triplet_{i}"
+                formatsubs = { f"{barf}_0": sql.Identifier( triplet[0] ),
+                               f"{barf}_1": sql.Identifier( triplet[1] ) }
+                conditions.append( sql.SQL( f"q3c_radial_query({{{barf}_0}},{{{barf}_1}},"
+                                            f"%({barf}_0)s,%({barf}_1)s,%({barf}_2)s)"
+                                           ).format( **formatsubs ) )
+                subdict.update( { f"{barf}_0": data[triplet[0]],
+                                  f"{barf}_1": data[triplet[1]],
+                                  f"{barf}_2": data[triplet[2]] / 3600. } )
+                del data[triplet[0]]
+                del data[triplet[1]]
+                del data[triplet[2]]
+
+        for i, pair in enumerate(cornerpolypairs):
+            presencecheck = [ ( i in data and data[i] is not None ) for i in pair ]
+            if any( presencecheck ):
+                if not all( presencecheck ):
+                    raise RuntimeError( f"Must include both or neither of {pair}" )
+                barf = f"corner_pair_{i}"
+                # THINKING AHEAD : this poly query doesn't use the q3c index
+                # As the number of database rows get large, we should look
+                # at performance.  We many need to do this in two steps,
+                # which would mean using a temp table.  First step would use
+                # regular indexes on the eight corner variables and use
+                # LEAST and GREATEST with ra and dec.  Then, a second query
+                # would use the poly query on the temp table resulting from
+                # that first query.  (Or maybe you can do it all with clever
+                # nested queries.)  This becomes very complicated.
+                conditions.append( sql.SQL( f"q3c_poly_query(%({barf}_0)s, %({barf}_1)s, "
+                                            f"ARRAY[ ra_corner_00, dec_corner_00, ra_corner_01, dec_corner_01, "
+                                            f"       ra_corner_11, dec_corner_11, ra_corner_10, dec_corner_10 ] )"
+                                           ) )
+                subdict.update( { f"{barf}_0": data[pair[0]],
+                                  f"{barf}_1": data[pair[1]] } )
+                del data[pair[0]]
+                del data[pair[1]]
+
+        for kw in equalses:
+            if ( kw in data ) and ( data[kw] is not None ):
+                conditions.append( sql.SQL( f"{kw}=%({kw})s" ) )
+                # I hate that we're doing str here, but we have a legacy of diaobject names
+                #   being either strings or integers
+                subdict[kw] = str( data[kw] )
+                del data[kw]
+
+        for kw in minmaxes:
+            if kw in data:
+                if data['kw'] is not None:
+                    conditions.append( sql.SQL( f"{kw}=%({kw})s" ) )
+                    subdict[kw] = data[kw]
+                del data[kw]
+            for edge, op in zip( [ 'min', 'max' ], [ '>=', '<=' ] ):
+                if f'{kw}_{edge}' in data:
+                    if data[f'{kw}_{edge}'] is not None:
+                        conditions.append( sql.SQL( f"{kw} {op} %({kw}_{edge})s" ) )
+                        subdict[f'{kw}_{edge}'] = data[f'{kw}_{edge}']
+                    del data[f'{kw}_{edge}']
+
+        _and = None
+        for condition in conditions:
+            if _and is None:
+                condstr = condition
+            else:
+                _and = " AND "
+                condstr += sql.SQL(_and) + condition
+
+        return data, condstr, subdict, finalclause
+
+
+    def check_auth( self ):
+        self.username = flask.session['username'] if 'username' in flask.session else '(None)'
+        self.displayname = flask.session['userdisplayname'] if 'userdisplayname' in flask.session else '(None)'
+        self.authenticated = ( 'authenticated' in flask.session ) and flask.session['authenticated']
+        self.user = None
+        if self.authenticated:
+            with db.DB() as conn:
+                cursor = conn.cursor()
+                cursor.execute( "SELECT id,username,displayname,email FROM authuser WHERE username=%(username)s",
+                                {'username': self.username } )
+                rows = cursor.fetchall()
+                if len(rows) > 1:
+                    self.authenticated = False
+                    raise RuntimeError( f"Error, more than one {self.username} in database, "
+                                        f"this should never happen." )
+                if len(rows) == 0:
+                    self.authenticated = False
+                    raise ValueError( f"Error, failed to find user {self.username} in database" )
+                row = rows[0]
+                self.user = SimpleNamespace( id=row[0], username=row[1], displayname=row[2], email=row[3] )
+                # Verify that session displayname and database displayname match?  Eh.  Whatevs.
+        return self.authenticated
+
+    def dispatch_request( self, *args, **kwargs ):
+        if not self.check_auth():
+            return "Not logged in", 500
+        if ( self._admin_required ) and ( not self.user.isadmin ):
+            return "Action requires admin", 500
+        try:
+            retval = self.do_the_things( *args, **kwargs )
+            # Can't just use the default JSON handling, because it
+            #   writes out NaN which is not standard JSON and which
+            #   the javascript JSON parser chokes on.  Sigh.
+            if isinstance( retval, dict ) or isinstance( retval, list ):
+                # SNLogger.warning( f"Dumping to json: {retval}" )
+                return ( simplejson.dumps( retval, ignore_nan=True, cls=SNPITJsonEncoder ),
+                         200, { 'Content-Type': 'application/json' } )
+            elif isinstance( retval, str ):
+                return retval, 200, { 'Content-Type': 'text/plain; charset=utf-8' }
+            elif isinstance( retval, tuple ):
+                return retval
+            else:
+                return retval, 200, { 'Content-Type': 'application/octet-stream' }
+        except Exception as ex:
+            # sio = io.StringIO()
+            # traceback.print_exc( file=sio )
+            # SNLogger.debug( sio.getvalue() )
+            SNLogger.exception( str(ex) )
+            return str(ex), 500

{roman_snpit_snappl-0.20.0 → roman_snpit_snappl-0.21.0}/snappl/db/db.py

@@ -13,6 +13,7 @@ from contextlib import contextmanager
 
 import numpy as np
 import psycopg
+from psycopg import sql
 
 from snappl.config import Config
 from snappl.logger import SNLogger
@@ -266,7 +267,8 @@ class DBCon:
 
         """
         if self.echoqueries and not silent:
-            SNLogger.debug( f"Sending query\n{q}\nwith substitutions: {subdict}" )
+            qprint = q.as_string() if isinstance( q, sql.Composable ) else q
+            SNLogger.debug( f"Sending query\n{qprint}\nwith substitutions: {subdict}" )
 
         if self.alwaysexplain and not silent:
             self.cursor.execute( f"EXPLAIN {q}", subdict )
@@ -1074,6 +1076,14 @@ class SummedImage( DBBase ):
     _pk = [ 'id' ]
 
 
+# ======================================================================
+
+class SegMap( DBBase ):
+    __tablename__ = "segmap"
+    _tablemeta = None
+    _pk = [ 'id' ]
+
+
 # ======================================================================
 
 class Lightcurve( DBBase ):

roman_snpit_snappl-0.21.0/snappl/db/migrations/20251028_segmap.sql

@@ -0,0 +1,45 @@
+CREATE TABLE segmap(
+    id UUID PRIMARY KEY,
+    provenance_id UUID NOT NULL,
+    band text NOT NULL,
+    ra double precision NOT NULL,
+    dec double precision NOT NULL,
+    ra_corner_00 real NOT NULL,
+    ra_corner_01 real NOT NULL,
+    ra_corner_10 real NOT NULL,
+    ra_corner_11 real NOT NULL,
+    dec_corner_00 real NOT NULL,
+    dec_corner_01 real NOT NULL,
+    dec_corner_10 real NOT NULL,
+    dec_corner_11 real NOT NULL,
+    filepath text NOT NULL,
+    width smallint,
+    height smallint,
+    format smallint NOT NULL DEFAULT 0,
+    l2image_id UUID DEFAULT NULL
+);
+CREATE INDEX ix_segmap_band ON segmap (band);
+CREATE INDEX ix_segmap_q3c ON segmap (q3c_ang2ipix(ra,dec));
+CREATE INDEX ix_segmap_ra00 ON segmap (ra_corner_00);
+CREATE INDEX ix_segmap_ra01 ON segmap (ra_corner_01);
+CREATE INDEX ix_segmap_ra10 ON segmap (ra_corner_10);
+CREATE INDEX ix_segmap_ra11 ON segmap (ra_corner_11);
+CREATE INDEX ix_segmap_dec00 ON segmap (dec_corner_00);
+CREATE INDEX ix_segmap_dec01 ON segmap (dec_corner_01);
+CREATE INDEX ix_segmap_dec10 ON segmap (dec_corner_10);
+CREATE INDEX ix_segmap_dec11 ON segmap (dec_corner_11);
+CREATE UNIQUE INDEX ix_segmap_filepath ON segmap (filepath);
+CREATE INDEX iX_segmap_l2image ON segmap (l2image_id);
+ALTER TABLE segmap ADD CONSTRAINT fk_segmap_l2image
+  FOREIGN KEY(l2image_id) REFERENCES l2image(id) ON DELETE RESTRICT;
+COMMENT ON TABLE segmap IS 'Segmentation maps';
+COMMENT ON COLUMN segmap.ra_corner_00 IS 'RA of pixel (0,0)';
+COMMENT ON COLUMN segmap.ra_corner_01 IS 'RA of pixel (0,height-1)';
+COMMENT ON COLUMN segmap.ra_corner_10 IS 'RA of pixel (width-1,0)';
+COMMENT ON COLUMN segmap.ra_corner_11 IS 'RA of pixel (width-1,height-1)';
+COMMENT ON COLUMN segmap.dec_corner_00 IS 'Dec of pixel (0,0)';
+COMMENT ON COLUMN segmap.dec_corner_01 IS 'Dec of pixel (0,height-1)';
+COMMENT ON COLUMN segmap.dec_corner_10 IS 'Dec of pixel (width-1,0)';
+COMMENT ON COLUMN segmap.dec_corner_11 IS 'Dec of pixel (width-1,height-1)';
+COMMENT ON COLUMN segmap.l2image_id IS 'This segmentation map is for this image';
+COMMENT ON COLUMN segmap.format IS '0=Unknown, 1=OpenUniverse2024FITSImage';