Return to tty.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / others / quipu / photo

Annotation of 43BSDReno/contrib/isode-beta/others/quipu/photo/tty.c, revision 1.1

1.1     ! root        1: /* tty.c - display on any terminal */
        !             2: 
        !             3: #ifndef        lint
        !             4: static char *rcsid = "$Header: /f/osi/others/quipu/photo/RCS/tty.c,v 7.0 89/11/23 22:01:49 mrose Rel $";
        !             5: #endif
        !             6: 
        !             7: /* 
        !             8:  * $Header: /f/osi/others/quipu/photo/RCS/tty.c,v 7.0 89/11/23 22:01:49 mrose Rel $
        !             9:  *
        !            10:  *
        !            11:  * $Log:       tty.c,v $
        !            12:  * Revision 7.0  89/11/23  22:01:49  mrose
        !            13:  * Release 6.0
        !            14:  * 
        !            15:  */
        !            16: 
        !            17: /*
        !            18:  *                               NOTICE
        !            19:  *
        !            20:  *    Acquisition, use, and distribution of this module and related
        !            21:  *    materials are subject to the restrictions of a license agreement.
        !            22:  *    Consult the Preface in the User's Manual for the full terms of
        !            23:  *    this agreement.
        !            24:  *
        !            25:  */
        !            26: 
        !            27: 
        !            28: 
        !            29: #include "stdio.h"
        !            30: #include "quipu/photo.h"
        !            31: 
        !            32: #define GREYSCALE "#OI&\\*o=_\"-;:,.  "
        !            33: 
        !            34: char    mapping[16];
        !            35: char * strcpy ();
        !            36: 
        !            37: char    buffer[500][500];
        !            38: int     lineno = 0,
        !            39:         pos = 0;
        !            40: extern int PIC_LINESIZE;
        !            41: extern int NUMLINES;
        !            42: int     scale = 8;
        !            43: int     invert = 0;
        !            44: int     equal = 0;
        !            45: int     ln = 0;
        !            46: int     scalediv = 0;
        !            47: int     edges = 0;
        !            48: 
        !            49: char    level[128];
        !            50: char    show[128];
        !            51: char    display[50][50];
        !            52: 
        !            53: /* ARGSUSED */
        !            54: photo_start (name)
        !            55: char   *name;
        !            56: {
        !            57:        char   *ptr,
        !            58:               *getenv ();
        !            59: 
        !            60: 
        !            61:        if ((ptr = getenv ("photo_invert")) != (char *) NULL)
        !            62:                if (strcmp (ptr, "true") == 0)
        !            63:                        invert = 1;
        !            64: 
        !            65:        if ((ptr = getenv ("photo_equal")) != (char *) NULL) {
        !            66:                if (strcmp (ptr, "true") == 0)
        !            67:                        equal = 1;
        !            68:                else if (strcmp (ptr, "edge") == 0) {
        !            69:                        int     i,
        !            70:                                j;
        !            71: 
        !            72:                        for (i = 1; i < PIC_LINESIZE; i++)
        !            73:                                for (j = 1; j < NUMLINES; j++)
        !            74:                                        buffer[i][j] = 0;
        !            75:                        edges = 1;
        !            76:                }
        !            77:        }
        !            78:        if ((ptr = getenv ("photo_mapping")) != (char *) NULL)
        !            79:                (void) strcpy (mapping, ptr);
        !            80:        else
        !            81:                (void) strcpy (mapping, GREYSCALE);
        !            82: 
        !            83:        if ((ptr = getenv ("photo_scale")) != (char *) NULL) {
        !            84:                if (strcmp (ptr, "large") == 0)
        !            85:                        scale = 1;
        !            86:                else if (strcmp (ptr, "small") == 0)
        !            87:                        scale = 8;
        !            88:                else if (strcmp (ptr, "medium") == 0)
        !            89:                        scale = 4;
        !            90:        }
        !            91:        scalediv = scale * scale / 8;
        !            92: 
        !            93:        (void) printf ("\n");
        !            94:        return (0);
        !            95: }
        !            96: 
        !            97: /* ARGSUSED */
        !            98: photo_end (name)
        !            99: char   *name;
        !           100: {
        !           101:        int     i,
        !           102:                j,
        !           103:                k;
        !           104:        int     numlev;
        !           105:        int     total = 0;
        !           106:        int     totlevel = 0;
        !           107:        int     cnt;
        !           108: 
        !           109:        if (equal) {
        !           110:                numlev = scale * scale * 2;
        !           111:                for (i = 0; i < numlev; i++)
        !           112:                        level[i] = 0;
        !           113: 
        !           114:                for (i = 0; i < ln; i++)
        !           115:                        for (j = 0; j < PIC_LINESIZE / scale; j++)
        !           116:                                level[display[i][j]]++;
        !           117: 
        !           118:                for (i = 0; i < numlev; i++)
        !           119:                        totlevel += level[i];
        !           120: 
        !           121:                for (i = 0; i < numlev; i++) {
        !           122:                        total += level[i];
        !           123:                        show[i] = (total * 16) / totlevel;
        !           124:                        if (show[i] >= 16)
        !           125:                                show[i] = 15;
        !           126:                }
        !           127: 
        !           128:                for (i = 0; i < ln; i++) {
        !           129:                        for (j = 0; j < PIC_LINESIZE / scale; j++) {
        !           130:                                if (invert)
        !           131:                                        (void) putc (mapping[show[display[i][j]]],stdout);
        !           132:                                else
        !           133:                                        (void) putc (mapping[15 - show[display[i][j]]],stdout);
        !           134:                        }
        !           135:                        (void) printf ("\n");
        !           136:                }
        !           137:        } else if (edges) {
        !           138:                /* edges by expansion */
        !           139:                char    ebuf[500][500];
        !           140: 
        !           141:                for (i = 1; i < PIC_LINESIZE; i++)
        !           142:                        for (j = 1; j < NUMLINES; j++)
        !           143:                                ebuf[i][j] = 0;
        !           144: 
        !           145:                for (i = 1; i < PIC_LINESIZE; i++)
        !           146:                        for (j = 1; j < NUMLINES; j++)
        !           147:                                if (buffer[i][j] == 1) {
        !           148:                                        ebuf[i - 1][j - 1] = 1;
        !           149:                                        ebuf[i - 1][j] = 1;
        !           150:                                        ebuf[i - 1][j + 1] = 1;
        !           151:                                        ebuf[i][j - 1] = 1;
        !           152:                                        ebuf[i][j + 1] = 1;
        !           153:                                        ebuf[i + 1][j - 1] = 1;
        !           154:                                        ebuf[i + 1][j] = 1;
        !           155:                                        ebuf[i + 1][j + 1] = 1;
        !           156:                                }
        !           157:                for (i = 1; i < PIC_LINESIZE; i++)
        !           158:                        for (j = 1; j < NUMLINES; j++)
        !           159:                                if (buffer[i][j] == 1)
        !           160:                                        ebuf[i][j] = 0;
        !           161: 
        !           162:                for (lineno = 0; lineno < NUMLINES; lineno += (2 * scale)) {
        !           163:                        for (k = 0; k < PIC_LINESIZE; k += scale) {
        !           164:                                cnt = 0;
        !           165:                                for (i = k; i < k + scale; i++)
        !           166:                                        for (j = lineno; j < (2 * scale) + lineno; j++)
        !           167:                                                cnt += ebuf[i][j];
        !           168: 
        !           169: /* Need to select a grey level on the strength of the edge
        !           170:  *
        !           171:  *                             cnt *= 4;
        !           172:  *                             if (cnt == (scalediv * 16))
        !           173:  *                                     cnt = (scalediv * 16) -1;
        !           174:  *
        !           175:  * Just set "strong" edge cells "on" for now ...
        !           176:  */
        !           177:                                if (cnt > (scalediv * 2) )
        !           178:                                        cnt = (scalediv * 16) -1;
        !           179:                                else 
        !           180:                                        cnt = 0;        
        !           181: 
        !           182:                                if (invert)
        !           183:                                        (void) putc (mapping[(cnt / scalediv)],stdout);
        !           184:                                else
        !           185:                                        (void) putc (mapping[15 - (cnt / scalediv)],stdout);
        !           186:                        }
        !           187:                        (void) putc ('\n',stdout);
        !           188:                }
        !           189: 
        !           190:        }
        !           191:        return (0);
        !           192: 
        !           193: }
        !           194: 
        !           195: photo_black (length)
        !           196: int     length;
        !           197: {
        !           198:        int     i;
        !           199: 
        !           200:        if (scale == 1) {
        !           201:                for (i = pos; i < length + pos; i++)
        !           202:                        if (invert)
        !           203:                                (void) putc (' ',stdout);
        !           204:                        else
        !           205:                                (void) putc ('#',stdout);
        !           206:                return;
        !           207:        }
        !           208:        for (i = pos; i < length + pos; i++)
        !           209:                buffer[i][lineno] = 1;
        !           210:        pos += length;
        !           211: }
        !           212: 
        !           213: photo_white (length)
        !           214: int     length;
        !           215: {
        !           216:        int     i;
        !           217: 
        !           218:        if (scale == 1) {
        !           219:                for (i = pos; i < length + pos; i++)
        !           220:                        if (invert)
        !           221:                                (void) putc ('#',stdout);
        !           222:                        else
        !           223:                                (void) putc (' ',stdout);
        !           224:                return;
        !           225:        }
        !           226:        for (i = pos; i < length + pos; i++)
        !           227:                buffer[i][lineno] = 0;
        !           228:        pos += length;
        !           229: }
        !           230: 
        !           231: /* ARGSUSED */
        !           232: photo_line_end (line)
        !           233: bit_string *line;
        !           234: {
        !           235:        int     i,
        !           236:                j,
        !           237:                k,
        !           238:                cnt;
        !           239: 
        !           240:        if (scale == 1) {
        !           241:                (void) putc ('\n',stdout);
        !           242:                return;
        !           243:        }
        !           244:        lineno++;
        !           245:        pos = 0;
        !           246: 
        !           247:        if (edges)
        !           248:                return;
        !           249: 
        !           250:        if (lineno >= 2 * scale) {
        !           251:                ln++;
        !           252:                lineno = 0;
        !           253:                for (k = 0; k < PIC_LINESIZE; k += scale) {
        !           254:                        cnt = 0;
        !           255:                        for (i = k; i < k + scale; i++)
        !           256:                                for (j = 0; j < 2 * scale; j++)
        !           257:                                        cnt += buffer[i][j];
        !           258: 
        !           259:                        if (equal) {
        !           260:                                display[ln][k / scale] = cnt;
        !           261:                                continue;
        !           262:                        }
        !           263:                        if (cnt == (scalediv * 16))
        !           264:                                cnt--;
        !           265: 
        !           266: 
        !           267:                        if (invert)
        !           268:                                (void) putc (mapping[cnt / scalediv],stdout);
        !           269:                        else
        !           270:                                (void) putc (mapping[15 - (cnt / scalediv)],stdout);
        !           271:                }
        !           272: 
        !           273:                if (!equal)
        !           274:                        (void) putc ('\n',stdout);
        !           275:        }
        !           276: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.